ydb-qdrant 7.0.1 → 8.1.0

package/dist/utils/vectorBinary.js

@@ -1,3 +1,4 @@
+const IS_LITTLE_ENDIAN = new Uint8Array(new Uint16Array([0x00ff]).buffer)[0] === 0xff;
 export function vectorToFloatBinary(vector) {
     if (vector.length === 0) {
         return Buffer.from([1]);
@@ -8,7 +9,12 @@ export function vectorToFloatBinary(vector) {
         if (!Number.isFinite(value)) {
             throw new Error(`Non-finite value in vector at index ${i}: ${value}`);
         }
-        buffer.writeFloatLE(value, i * 4);
+        if (IS_LITTLE_ENDIAN) {
+            buffer.writeFloatLE(value, i * 4);
+        }
+        else {
+            buffer.writeFloatBE(value, i * 4);
+        }
     }
     buffer.writeUInt8(1, vector.length * 4);
     return buffer;
@@ -24,10 +30,9 @@ export function vectorToBitBinary(vector) {
     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) {
+        if (IS_LITTLE_ENDIAN) {
             buffer.writeBigUInt64LE(v, offset);
         }
         else {
@@ -36,7 +41,7 @@ export function vectorToBitBinary(vector) {
         offset += 8;
     };
     const writeU32 = (v) => {
-        if (isLittleEndian) {
+        if (IS_LITTLE_ENDIAN) {
             buffer.writeUInt32LE(v, offset);
         }
         else {
@@ -45,7 +50,7 @@ export function vectorToBitBinary(vector) {
         offset += 4;
     };
     const writeU16 = (v) => {
-        if (isLittleEndian) {
+        if (IS_LITTLE_ENDIAN) {
             buffer.writeUInt16LE(v, offset);
         }
         else {

package/dist/ydb/bootstrapMetaTable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates the qdr__collections metadata table if it does not exist.
+ *
+ * Intended for CI and local dev environments where a fresh YDB is provisioned
+ * and schema creation is handled out-of-band from `ensureMetaTable()`.
+ */
+export declare function bootstrapMetaTable(): Promise<void>;

package/dist/ydb/bootstrapMetaTable.js

@@ -0,0 +1,75 @@
+import { Column, TableDescription, Types, destroyDriver, readyOrThrow, withSession, } from "./client.js";
+function isTableNotFoundError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return (/table.*not found/i.test(msg) ||
+        /path.*not found/i.test(msg) ||
+        /does not exist/i.test(msg) ||
+        /NotFound\s*\(code\s*400140\)/i.test(msg) ||
+        (/SchemeError\s*\(code\s*400070\)/i.test(msg) &&
+            /:\s*\[\s*\]\s*$/i.test(msg)));
+}
+function isAlreadyExistsError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /already exists/i.test(msg) || /path.*exists/i.test(msg);
+}
+/**
+ * Creates the qdr__collections metadata table if it does not exist.
+ *
+ * Intended for CI and local dev environments where a fresh YDB is provisioned
+ * and schema creation is handled out-of-band from `ensureMetaTable()`.
+ */
+export async function bootstrapMetaTable() {
+    await readyOrThrow();
+    await withSession(async (s) => {
+        let desc = null;
+        try {
+            desc = await s.describeTable("qdr__collections");
+        }
+        catch (err) {
+            if (!isTableNotFoundError(err)) {
+                throw err;
+            }
+            const td = new TableDescription()
+                .withColumns(new Column("collection", Types.UTF8), new Column("table_name", Types.UTF8), new Column("vector_dimension", Types.UINT32), new Column("distance", Types.UTF8), new Column("vector_type", Types.UTF8), new Column("created_at", Types.TIMESTAMP), new Column("last_accessed_at", Types.TIMESTAMP))
+                .withPrimaryKey("collection");
+            try {
+                await s.createTable("qdr__collections", td);
+                console.log("bootstrapMetaTable: created qdr__collections");
+            }
+            catch (createErr) {
+                if (!isAlreadyExistsError(createErr)) {
+                    throw createErr;
+                }
+            }
+            desc = await s.describeTable("qdr__collections");
+        }
+        const cols = desc?.columns ?? [];
+        const hasLastAccessedAt = cols.some((c) => c.name === "last_accessed_at");
+        if (!hasLastAccessedAt) {
+            throw new Error("bootstrapMetaTable: qdr__collections exists but is missing required column last_accessed_at");
+        }
+    });
+}
+// CLI entrypoint
+if (process.argv[1]?.endsWith("bootstrapMetaTable.js")) {
+    const main = async () => {
+        await bootstrapMetaTable();
+        // Important: ydb-sdk driver/session pool keeps timers alive; explicitly
+        // destroy it so this script can terminate in CI steps.
+        await destroyDriver();
+    };
+    main()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch(async (err) => {
+        console.error(err);
+        try {
+            await destroyDriver();
+        }
+        catch {
+            // ignore cleanup errors
+        }
+        process.exit(1);
+    });
+}

package/dist/ydb/client.d.ts

@@ -1,29 +1,36 @@
-import { Driver, type DriverOptions } from "@ydbjs/core";
-import { type QueryClient } from "@ydbjs/query";
-import { CredentialsProvider } from "@ydbjs/auth";
+import type { Session, IAuthService, ExecuteQuerySettings as YdbExecuteQuerySettings, BulkUpsertSettings as YdbBulkUpsertSettings, QuerySession } from "ydb-sdk";
+declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, ExecuteQuerySettings: typeof YdbExecuteQuerySettings, BulkUpsertSettings: typeof YdbBulkUpsertSettings, Ydb: typeof import("ydb-sdk-proto").Ydb;
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, BulkUpsertSettings, Ydb, };
+export declare function createExecuteQuerySettings(options?: {
+    keepInCache?: boolean;
+    idempotent?: boolean;
+}): YdbExecuteQuerySettings;
+export declare function createExecuteQuerySettingsWithTimeout(options: {
+    keepInCache?: boolean;
+    idempotent?: boolean;
+    timeoutMs: number;
+}): YdbExecuteQuerySettings;
+export declare function createBulkUpsertSettingsWithTimeout(options: {
+    timeoutMs: number;
+}): YdbBulkUpsertSettings;
 type DriverConfig = {
     endpoint?: string;
     database?: string;
     connectionString?: string;
-    credentialsProvider?: CredentialsProvider;
+    authService?: IAuthService;
 };
 export declare function isCompilationTimeoutError(error: unknown): boolean;
-export declare function isTimeoutAbortError(error: unknown): boolean;
-export declare function getAbortErrorCause(error: unknown): unknown;
 export declare function __setDriverForTests(fake: unknown): void;
-export declare function __setSessionPoolForTests(fake: unknown): void;
-export declare function __setDriverFactoryForTests(factory: ((connectionString: string, options?: DriverOptions) => Driver) | undefined): void;
+export declare function __setDriverFactoryForTests(factory: ((config: unknown) => unknown) | undefined): void;
 export declare function __resetRefreshStateForTests(): void;
 export declare function configureDriver(config: DriverConfig): void;
-/**
- * @internal
- * Exposes the singleton YDB `Driver` for internal modules that need non-QueryService RPCs
- * (e.g. TableService BulkUpsert).
- */
-export declare function __getDriverForInternalUse(): Driver;
 export declare function readyOrThrow(): Promise<void>;
-export declare function withSession<T>(fn: (sql: QueryClient, signal: AbortSignal) => Promise<T>): Promise<T>;
-export declare function withStartupProbeSession<T>(fn: (sql: QueryClient, signal: AbortSignal) => Promise<T>): Promise<T>;
+export declare function withSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
+export declare function withQuerySession<T>(fn: (s: QuerySession) => Promise<T>, options?: {
+    timeoutMs?: number;
+    idempotent?: boolean;
+}): Promise<T>;
+export declare function withStartupProbeSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
 export declare function isYdbAvailable(timeoutMs?: number): Promise<boolean>;
 /**
  * Destroys the current driver and its session pool.
@@ -35,4 +42,3 @@ export declare function destroyDriver(): Promise<void>;
  * Use this to recover from session pool exhaustion or zombie sessions.
  */
 export declare function refreshDriver(): Promise<void>;
-export {};