presubmit 0.1.0

package/vendor/lancedb/dist/header.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Header providers for LanceDB remote connections.
+ *
+ * This module provides a flexible header management framework for LanceDB remote
+ * connections, allowing users to implement custom header strategies for
+ * authentication, request tracking, custom metadata, or any other header-based
+ * requirements.
+ *
+ * @module header
+ */
+/**
+ * Abstract base class for providing custom headers for each request.
+ *
+ * Users can implement this interface to provide dynamic headers for various purposes
+ * such as authentication (OAuth tokens, API keys), request tracking (correlation IDs),
+ * custom metadata, or any other header-based requirements. The provider is called
+ * before each request to ensure fresh header values are always used.
+ *
+ * @example
+ * Simple JWT token provider:
+ * ```typescript
+ * class JWTProvider extends HeaderProvider {
+ *   constructor(private token: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return { authorization: `Bearer ${this.token}` };
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * Provider with request tracking:
+ * ```typescript
+ * class RequestTrackingProvider extends HeaderProvider {
+ *   constructor(private sessionId: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return {
+ *       "X-Session-Id": this.sessionId,
+ *       "X-Request-Id": `req-${Date.now()}`
+ *     };
+ *   }
+ * }
+ * ```
+ */
+export declare abstract class HeaderProvider {
+    /**
+     * Get the latest headers to be added to requests.
+     *
+     * This method is called before each request to the remote LanceDB server.
+     * Implementations should return headers that will be merged with existing headers.
+     *
+     * @returns Dictionary of header names to values to add to the request.
+     * @throws If unable to fetch headers, the exception will be propagated and the request will fail.
+     */
+    abstract getHeaders(): Record<string, string>;
+}
+/**
+ * Example implementation: A simple header provider that returns static headers.
+ *
+ * This is an example implementation showing how to create a HeaderProvider
+ * for cases where headers don't change during the session.
+ *
+ * @example
+ * ```typescript
+ * const provider = new StaticHeaderProvider({
+ *   authorization: "Bearer my-token",
+ *   "X-Custom-Header": "custom-value"
+ * });
+ * const headers = provider.getHeaders();
+ * // Returns: {authorization: 'Bearer my-token', 'X-Custom-Header': 'custom-value'}
+ * ```
+ */
+export declare class StaticHeaderProvider extends HeaderProvider {
+    private _headers;
+    /**
+     * Initialize with static headers.
+     * @param headers - Headers to return for every request.
+     */
+    constructor(headers: Record<string, string>);
+    /**
+     * Return the static headers.
+     * @returns Copy of the static headers.
+     */
+    getHeaders(): Record<string, string>;
+}
+/**
+ * Token response from OAuth provider.
+ * @public
+ */
+export interface TokenResponse {
+    accessToken: string;
+    expiresIn?: number;
+}
+/**
+ * Example implementation: OAuth token provider with automatic refresh.
+ *
+ * This is an example implementation showing how to manage OAuth tokens
+ * with automatic refresh when they expire.
+ *
+ * @example
+ * ```typescript
+ * async function fetchToken(): Promise<TokenResponse> {
+ *   const response = await fetch("https://oauth.example.com/token", {
+ *     method: "POST",
+ *     body: JSON.stringify({
+ *       grant_type: "client_credentials",
+ *       client_id: "your-client-id",
+ *       client_secret: "your-client-secret"
+ *     }),
+ *     headers: { "Content-Type": "application/json" }
+ *   });
+ *   const data = await response.json();
+ *   return {
+ *     accessToken: data.access_token,
+ *     expiresIn: data.expires_in
+ *   };
+ * }
+ *
+ * const provider = new OAuthHeaderProvider(fetchToken);
+ * const headers = provider.getHeaders();
+ * // Returns: {"authorization": "Bearer <your-token>"}
+ * ```
+ */
+export declare class OAuthHeaderProvider extends HeaderProvider {
+    private _tokenFetcher;
+    private _refreshBufferSeconds;
+    private _currentToken;
+    private _tokenExpiresAt;
+    private _refreshPromise;
+    /**
+     * Initialize the OAuth provider.
+     * @param tokenFetcher - Function to fetch new tokens. Should return object with 'accessToken' and optionally 'expiresIn'.
+     * @param refreshBufferSeconds - Seconds before expiry to refresh token. Default 300 (5 minutes).
+     */
+    constructor(tokenFetcher: () => Promise<TokenResponse> | TokenResponse, refreshBufferSeconds?: number);
+    /**
+     * Check if token needs refresh.
+     */
+    private _needsRefresh;
+    /**
+     * Refresh the token if it's expired or close to expiring.
+     */
+    private _refreshTokenIfNeeded;
+    /**
+     * Get OAuth headers, refreshing token if needed.
+     * Note: This is synchronous for now as the Rust implementation expects sync.
+     * In a real implementation, this would need to handle async properly.
+     * @returns Headers with Bearer token authorization.
+     * @throws If unable to fetch or refresh token.
+     */
+    getHeaders(): Record<string, string>;
+    /**
+     * Manually refresh the token.
+     * Call this before using getHeaders() to ensure token is available.
+     */
+    refreshToken(): Promise<void>;
+}

package/vendor/lancedb/dist/header.js

@@ -0,0 +1,217 @@
+"use strict";
+// SPDX-License-Identifier: Apache-2.0
+// SPDX-FileCopyrightText: Copyright The LanceDB Authors
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OAuthHeaderProvider = exports.StaticHeaderProvider = exports.HeaderProvider = void 0;
+/**
+ * Header providers for LanceDB remote connections.
+ *
+ * This module provides a flexible header management framework for LanceDB remote
+ * connections, allowing users to implement custom header strategies for
+ * authentication, request tracking, custom metadata, or any other header-based
+ * requirements.
+ *
+ * @module header
+ */
+/**
+ * Abstract base class for providing custom headers for each request.
+ *
+ * Users can implement this interface to provide dynamic headers for various purposes
+ * such as authentication (OAuth tokens, API keys), request tracking (correlation IDs),
+ * custom metadata, or any other header-based requirements. The provider is called
+ * before each request to ensure fresh header values are always used.
+ *
+ * @example
+ * Simple JWT token provider:
+ * ```typescript
+ * class JWTProvider extends HeaderProvider {
+ *   constructor(private token: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return { authorization: `Bearer ${this.token}` };
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * Provider with request tracking:
+ * ```typescript
+ * class RequestTrackingProvider extends HeaderProvider {
+ *   constructor(private sessionId: string) {
+ *     super();
+ *   }
+ *
+ *   getHeaders(): Record<string, string> {
+ *     return {
+ *       "X-Session-Id": this.sessionId,
+ *       "X-Request-Id": `req-${Date.now()}`
+ *     };
+ *   }
+ * }
+ * ```
+ */
+class HeaderProvider {
+}
+exports.HeaderProvider = HeaderProvider;
+/**
+ * Example implementation: A simple header provider that returns static headers.
+ *
+ * This is an example implementation showing how to create a HeaderProvider
+ * for cases where headers don't change during the session.
+ *
+ * @example
+ * ```typescript
+ * const provider = new StaticHeaderProvider({
+ *   authorization: "Bearer my-token",
+ *   "X-Custom-Header": "custom-value"
+ * });
+ * const headers = provider.getHeaders();
+ * // Returns: {authorization: 'Bearer my-token', 'X-Custom-Header': 'custom-value'}
+ * ```
+ */
+class StaticHeaderProvider extends HeaderProvider {
+    _headers;
+    /**
+     * Initialize with static headers.
+     * @param headers - Headers to return for every request.
+     */
+    constructor(headers) {
+        super();
+        this._headers = { ...headers };
+    }
+    /**
+     * Return the static headers.
+     * @returns Copy of the static headers.
+     */
+    getHeaders() {
+        return { ...this._headers };
+    }
+}
+exports.StaticHeaderProvider = StaticHeaderProvider;
+/**
+ * Example implementation: OAuth token provider with automatic refresh.
+ *
+ * This is an example implementation showing how to manage OAuth tokens
+ * with automatic refresh when they expire.
+ *
+ * @example
+ * ```typescript
+ * async function fetchToken(): Promise<TokenResponse> {
+ *   const response = await fetch("https://oauth.example.com/token", {
+ *     method: "POST",
+ *     body: JSON.stringify({
+ *       grant_type: "client_credentials",
+ *       client_id: "your-client-id",
+ *       client_secret: "your-client-secret"
+ *     }),
+ *     headers: { "Content-Type": "application/json" }
+ *   });
+ *   const data = await response.json();
+ *   return {
+ *     accessToken: data.access_token,
+ *     expiresIn: data.expires_in
+ *   };
+ * }
+ *
+ * const provider = new OAuthHeaderProvider(fetchToken);
+ * const headers = provider.getHeaders();
+ * // Returns: {"authorization": "Bearer <your-token>"}
+ * ```
+ */
+class OAuthHeaderProvider extends HeaderProvider {
+    _tokenFetcher;
+    _refreshBufferSeconds;
+    _currentToken = null;
+    _tokenExpiresAt = null;
+    _refreshPromise = null;
+    /**
+     * Initialize the OAuth provider.
+     * @param tokenFetcher - Function to fetch new tokens. Should return object with 'accessToken' and optionally 'expiresIn'.
+     * @param refreshBufferSeconds - Seconds before expiry to refresh token. Default 300 (5 minutes).
+     */
+    constructor(tokenFetcher, refreshBufferSeconds = 300) {
+        super();
+        this._tokenFetcher = tokenFetcher;
+        this._refreshBufferSeconds = refreshBufferSeconds;
+    }
+    /**
+     * Check if token needs refresh.
+     */
+    _needsRefresh() {
+        if (this._currentToken === null) {
+            return true;
+        }
+        if (this._tokenExpiresAt === null) {
+            // No expiration info, assume token is valid
+            return false;
+        }
+        // Refresh if we're within the buffer time of expiration
+        const now = Date.now() / 1000;
+        return now >= this._tokenExpiresAt - this._refreshBufferSeconds;
+    }
+    /**
+     * Refresh the token if it's expired or close to expiring.
+     */
+    async _refreshTokenIfNeeded() {
+        if (!this._needsRefresh()) {
+            return;
+        }
+        // If refresh is already in progress, wait for it
+        if (this._refreshPromise) {
+            await this._refreshPromise;
+            return;
+        }
+        // Start refresh
+        this._refreshPromise = (async () => {
+            try {
+                const tokenData = await this._tokenFetcher();
+                this._currentToken = tokenData.accessToken;
+                if (!this._currentToken) {
+                    throw new Error("Token fetcher did not return 'accessToken'");
+                }
+                // Set expiration if provided
+                if (tokenData.expiresIn) {
+                    this._tokenExpiresAt = Date.now() / 1000 + tokenData.expiresIn;
+                }
+                else {
+                    // Token doesn't expire or expiration unknown
+                    this._tokenExpiresAt = null;
+                }
+            }
+            finally {
+                this._refreshPromise = null;
+            }
+        })();
+        await this._refreshPromise;
+    }
+    /**
+     * Get OAuth headers, refreshing token if needed.
+     * Note: This is synchronous for now as the Rust implementation expects sync.
+     * In a real implementation, this would need to handle async properly.
+     * @returns Headers with Bearer token authorization.
+     * @throws If unable to fetch or refresh token.
+     */
+    getHeaders() {
+        // For simplicity in this example, we assume the token is already fetched
+        // In a real implementation, this would need to handle the async nature properly
+        if (!this._currentToken && !this._refreshPromise) {
+            // Synchronously trigger refresh - this is a limitation of the current implementation
+            throw new Error("Token not initialized. Call refreshToken() first or use async initialization.");
+        }
+        if (!this._currentToken) {
+            throw new Error("Failed to obtain OAuth token");
+        }
+        return { authorization: `Bearer ${this._currentToken}` };
+    }
+    /**
+     * Manually refresh the token.
+     * Call this before using getHeaders() to ensure token is available.
+     */
+    async refreshToken() {
+        this._currentToken = null; // Force refresh
+        await this._refreshTokenIfNeeded();
+    }
+}
+exports.OAuthHeaderProvider = OAuthHeaderProvider;

package/vendor/lancedb/dist/index.d.ts

@@ -0,0 +1,246 @@
+import { Connection } from "./connection";
+import { ConnectNamespaceOptions, ConnectionOptions, Session } from "./native.js";
+import { HeaderProvider } from "./header";
+import type { BaseTokenizer } from "./indices";
+import type { FtsToken } from "./table";
+export { MaterializedView, MaterializedViewDefinition, MaterializedViewSelect, } from "./materialized_view";
+export { JsHeaderProvider as NativeJsHeaderProvider } from "./native.js";
+export { instrumentLanceDbMetrics } from "./otel";
+export { AddColumnsSql, ConnectionOptions, ConnectNamespaceOptions, IndexStatistics, IndexConfig, ClientConfig, TimeoutConfig, RetryConfig, TlsConfig, OptimizeStats, CompactionStats, RemovalStats, TableStatistics, FragmentStatistics, FragmentSummaryStats, Tags, TagContents, BranchContents, MergeResult, AddResult, AddColumnsResult, RefreshColumnResult, RefreshMaterializedViewResult, AlterColumnsResult, UpdateFieldMetadataResult, DeleteResult, DropColumnsResult, UpdateResult, SplitCalculatedOptions, SplitRandomOptions, SplitHashOptions, SplitSequentialOptions, ShuffleOptions, OAuthConfig as NativeOAuthConfig, } from "./native.js";
+export { makeArrowTable, MakeArrowTableOptions, Data, VectorColumnOptions, } from "./arrow";
+export { Connection, CreateTableOptions, TableNamesOptions, ListTablesOptions, OpenTableOptions, ListNamespacesOptions, CreateNamespaceOptions, DropNamespaceOptions, ListNamespacesResponse, ListTablesResponse, CreateNamespaceResponse, DropNamespaceResponse, DescribeNamespaceResponse, RenameTableOptions, } from "./connection";
+export { Job, JobDescription, JobFailureInfo, JobInfo, Session, } from "./native.js";
+export { AutoQuery, ExecutableQuery, Query, QueryBase, VectorQuery, TakeQuery, AnalyzePlanDistributedMetrics, QueryExecutionOptions, ColumnOrdering, FullTextSearchOptions, RecordBatchIterator, FullTextQuery, MatchQuery, PhraseQuery, BoostQuery, MultiMatchQuery, BooleanQuery, FullTextQueryType, Operator, Occur, } from "./query";
+export { Index, IndexOptions, IvfPqOptions, IvfRqOptions, IvfFlatOptions, HnswPqOptions, HnswSqOptions, FtsOptions, BaseTokenizer, } from "./indices";
+export { Table, Branches, BranchColumnSummary, BranchColumnChange, BranchIndexSummary, BranchRowCountSummary, CherryPickError, BranchDiff, CherryPickPreview, CherryPickResult, AddDataOptions, UpdateOptions, OptimizeOptions, Version, WriteProgress, FtsToken, TokenizeTableOptions, LsmWriteSpec, LsmStats, BucketStats, GenerationStats, MemtableStats, ColumnAlteration, FieldMetadataUpdate, } from "./table";
+export { HeaderProvider, StaticHeaderProvider, OAuthHeaderProvider, TokenResponse, } from "./header";
+export { OAuthConfig, OAuthFlowType } from "./oauth";
+export { MergeInsertBuilder, WriteExecutionOptions } from "./merge";
+export * as embedding from "./embedding";
+export { permutationBuilder, PermutationBuilder } from "./permutation";
+export { Scannable, ScannableOptions } from "./scannable";
+export * as rerankers from "./rerankers";
+export { SchemaLike, TableLike, FieldLike, RecordBatchLike, DataLike, IntoVector, MultiVector, } from "./arrow";
+export { IntoSql, packBits } from "./util";
+/**
+ * Options for tokenizing a full-text search query without a table index.
+ */
+export interface TokenizeOptions {
+    /**
+     * The tokenizer to use. The default is "simple".
+     */
+    baseTokenizer?: BaseTokenizer;
+    /** Language for stemming and stop words. */
+    language?: string;
+    /** Maximum token length; tokens longer than this are ignored. */
+    maxTokenLength?: number;
+    /** Whether to lowercase tokens. */
+    lowercase?: boolean;
+    /** Whether to stem tokens. */
+    stem?: boolean;
+    /** Whether to remove stop words. */
+    removeStopWords?: boolean;
+    /**
+     * Custom stop words that replace the built-in list for `language`.
+     *
+     * This option only affects tokenization when `removeStopWords` is true.
+     *
+     * `undefined` keeps the built-in language list. An empty array explicitly
+     * replaces it with no stop words.
+     */
+    customStopWords?: string[];
+    /** Whether to fold ASCII characters. */
+    asciiFolding?: boolean;
+    /** N-gram minimum length. */
+    ngramMinLength?: number;
+    /** N-gram maximum length. */
+    ngramMaxLength?: number;
+    /** Whether to only emit token prefixes for the n-gram tokenizer. */
+    prefixOnly?: boolean;
+}
+/**
+ * Tokenize a full-text search query using an explicit tokenizer.
+ *
+ * This does not require a table or FTS index. The tokenizer options match
+ * {@link Index.fts}.
+ */
+export declare function tokenize(query: string, options?: Partial<TokenizeOptions>): Promise<FtsToken[]>;
+/**
+ * Connect to a LanceDB instance at the given URI.
+ *
+ * Accepted formats:
+ *
+ * - `/path/to/database` - local database
+ * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
+ * - `db://host:port` - remote database (LanceDB cloud)
+ * @param {string} uri - The uri of the database. If the database uri starts
+ * with `db://` then it connects to a remote database.
+ * @see {@link ConnectionOptions} for more details on the URI format.
+ * @param  options - The options to use when connecting to the database
+ * @example
+ * ```ts
+ * const conn = await connect("/path/to/database");
+ * ```
+ * @example
+ * ```ts
+ * const conn = await connect(
+ *   "s3://bucket/path/to/database",
+ *   {storageOptions: {timeout: "60s"}
+ * });
+ * ```
+ * @example
+ * Using with a header provider for per-request authentication:
+ * ```ts
+ * const provider = new StaticHeaderProvider({
+ *   "X-API-Key": "my-key"
+ * });
+ * const conn = await connectWithHeaderProvider(
+ *   "db://host:port",
+ *   options,
+ *   provider
+ * );
+ * ```
+ */
+export declare function connect(uri: string, options?: Partial<ConnectionOptions>, session?: Session, headerProvider?: HeaderProvider | (() => Record<string, string>) | (() => Promise<Record<string, string>>)): Promise<Connection>;
+/**
+ * Connect to a LanceDB instance at the given URI.
+ *
+ * Accepted formats:
+ *
+ * - `/path/to/database` - local database
+ * - `s3://bucket/path/to/database` or `gs://bucket/path/to/database` - database on cloud storage
+ * - `db://host:port` - remote database (LanceDB cloud)
+ * @param  options - The options to use when connecting to the database
+ * @see {@link ConnectionOptions} for more details on the URI format.
+ * @example
+ * ```ts
+ * const conn = await connect({
+ *   uri: "/path/to/database",
+ *   storageOptions: {timeout: "60s"}
+ * });
+ * ```
+ *
+ * @example
+ * ```ts
+ * const session = Session.default();
+ * const conn = await connect({
+ *   uri: "/path/to/database",
+ *   session: session
+ * });
+ * ```
+ */
+export declare function connect(options: Partial<ConnectionOptions> & {
+    uri: string;
+}): Promise<Connection>;
+/**
+ * Configuration for the built-in directory namespace (`"dir"`).
+ *
+ * The directory namespace stores tables under a single root path (local
+ * filesystem or object storage URI). See
+ * {@link https://docs.lancedb.com/namespaces} for the documented surface;
+ * less-common knobs live under {@link DirNamespaceConfig.extraProperties}.
+ */
+export interface DirNamespaceConfig {
+    /** Root path or URI containing the LanceDB tables. */
+    root: string;
+    /**
+     * Whether to maintain a namespace manifest at the root. Required for
+     * child namespaces. Defaults to true on the impl side.
+     */
+    manifestEnabled?: boolean;
+    /**
+     * Additional raw properties passed verbatim to the namespace
+     * implementation (e.g. `storage.*`, `credential_vendor.*`). Typed
+     * fields above take precedence on key collision.
+     */
+    extraProperties?: Record<string, string>;
+}
+/**
+ * Configuration for the built-in REST namespace (`"rest"`).
+ *
+ * The REST namespace talks to a remote catalog server over HTTP. See
+ * {@link https://docs.lancedb.com/namespaces} for the documented surface;
+ * less-common knobs (TLS, metrics) live under
+ * {@link RestNamespaceConfig.extraProperties}.
+ */
+export interface RestNamespaceConfig {
+    /** Catalog endpoint URL. */
+    uri: string;
+    /**
+     * HTTP headers forwarded with each request. Keys are passed through
+     * as-is (e.g. `"x-api-key"`, `"Authorization"`).
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional raw properties passed verbatim to the namespace
+     * implementation (e.g. `tls.*`, `ops_metrics_enabled`, `delimiter`).
+     * Typed fields above take precedence on key collision.
+     */
+    extraProperties?: Record<string, string>;
+}
+/**
+ * Connect to a LanceDB database through a namespace.
+ *
+ * Unlike {@link connect}, which routes by URI scheme (local path vs.
+ * `db://` cloud), `connectNamespace` always returns a namespace-backed
+ * connection. The `implName` selects the namespace implementation:
+ *
+ * - `"dir"` — directory namespace, configured with {@link DirNamespaceConfig}.
+ * - `"rest"` — remote REST catalog, configured with {@link RestNamespaceConfig}.
+ * - Any other string — full module path for a custom implementation,
+ *   configured with a free-form string-keyed `properties` map.
+ *
+ * @example Typed dir namespace
+ * ```ts
+ * const db = await connectNamespace("dir", { root: "/path/to/db" });
+ * await db.createTable("users", [{ id: 1 }]);
+ * ```
+ *
+ * @example Typed REST namespace with auth headers
+ * ```ts
+ * const db = await connectNamespace("rest", {
+ *   uri: "https://catalog.example.com",
+ *   headers: { "x-api-key": process.env.CATALOG_KEY ?? "" },
+ * });
+ * ```
+ *
+ * @example Custom implementation with raw properties
+ * ```ts
+ * const db = await connectNamespace("my.custom.Namespace", {
+ *   endpoint: "...",
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: "dir", config: DirNamespaceConfig, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;
+/**
+ * Connect through the built-in REST namespace.
+ *
+ * Configured with {@link RestNamespaceConfig}. See the function-level
+ * documentation above for the full surface, examples, and how this
+ * relates to {@link connect}.
+ *
+ * @example
+ * ```ts
+ * const db = await connectNamespace("rest", {
+ *   uri: "https://catalog.example.com",
+ *   headers: { "x-api-key": process.env.CATALOG_KEY ?? "" },
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: "rest", config: RestNamespaceConfig, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;
+/**
+ * Connect through a custom namespace implementation by full module path,
+ * configured with a free-form string-keyed `properties` map. Use the
+ * typed overloads above for the built-in `"dir"` and `"rest"` impls.
+ *
+ * See the function-level documentation above for examples and how this
+ * relates to {@link connect}.
+ *
+ * @example
+ * ```ts
+ * const db = await connectNamespace("my.custom.Namespace", {
+ *   endpoint: "...",
+ * });
+ * ```
+ */
+export declare function connectNamespace(implName: string, properties: Record<string, string>, options?: Partial<ConnectNamespaceOptions>): Promise<Connection>;