@lancedb/lancedb 0.5.2 → 0.7.0

package/native.d.ts

@@ -0,0 +1,208 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+/** A description of an index currently configured on a column */
+export interface IndexConfig {
+  /** The name of the index */
+  name: string
+  /** The type of the index */
+  indexType: string
+  /**
+   * The columns in the index
+   *
+   * Currently this is always an array of size 1. In the future there may
+   * be more columns to represent composite indices.
+   */
+  columns: Array<string>
+}
+/** Statistics about a compaction operation. */
+export interface CompactionStats {
+  /** The number of fragments removed */
+  fragmentsRemoved: number
+  /** The number of new, compacted fragments added */
+  fragmentsAdded: number
+  /** The number of data files removed */
+  filesRemoved: number
+  /** The number of new, compacted data files added */
+  filesAdded: number
+}
+/** Statistics about a cleanup operation */
+export interface RemovalStats {
+  /** The number of bytes removed */
+  bytesRemoved: number
+  /** The number of old versions removed */
+  oldVersionsRemoved: number
+}
+/** Statistics about an optimize operation */
+export interface OptimizeStats {
+  /** Statistics about the compaction operation */
+  compaction: CompactionStats
+  /** Statistics about the removal operation */
+  prune: RemovalStats
+}
+/**
+ *  A definition of a column alteration. The alteration changes the column at
+ * `path` to have the new name `name`, to be nullable if `nullable` is true,
+ * and to have the data type `data_type`. At least one of `rename` or `nullable`
+ * must be provided.
+ */
+export interface ColumnAlteration {
+  /**
+   * The path to the column to alter. This is a dot-separated path to the column.
+   * If it is a top-level column then it is just the name of the column. If it is
+   * a nested column then it is the path to the column, e.g. "a.b.c" for a column
+   * `c` nested inside a column `b` nested inside a column `a`.
+   */
+  path: string
+  /**
+   * The new name of the column. If not provided then the name will not be changed.
+   * This must be distinct from the names of all other columns in the table.
+   */
+  rename?: string
+  /** Set the new nullability. Note that a nullable column cannot be made non-nullable. */
+  nullable?: boolean
+}
+/** A definition of a new column to add to a table. */
+export interface AddColumnsSql {
+  /** The name of the new column. */
+  name: string
+  /**
+   * The values to populate the new column with, as a SQL expression.
+   * The expression can reference other columns in the table.
+   */
+  valueSql: string
+}
+export interface IndexStatistics {
+  /** The number of rows indexed by the index */
+  numIndexedRows: number
+  /** The number of rows not indexed */
+  numUnindexedRows: number
+  /** The type of the index */
+  indexType?: string
+  /** The metadata for each index */
+  indices: Array<IndexMetadata>
+}
+export interface IndexMetadata {
+  metricType?: string
+  indexType?: string
+}
+export interface ConnectionOptions {
+  /**
+   * (For LanceDB OSS only): The interval, in seconds, at which to check for
+   * updates to the table from other processes. If None, then consistency is not
+   * checked. For performance reasons, this is the default. For strong
+   * consistency, set this to zero seconds. Then every read will check for
+   * updates from other processes. As a compromise, you can set this to a
+   * non-zero value for eventual consistency. If more than that interval
+   * has passed since the last check, then the table will be checked for updates.
+   * Note: this consistency only applies to read operations. Write operations are
+   * always consistent.
+   */
+  readConsistencyInterval?: number
+  /**
+   * (For LanceDB OSS only): configuration for object storage.
+   *
+   * The available options are described at https://lancedb.github.io/lancedb/guides/storage/
+   */
+  storageOptions?: Record<string, string>
+}
+/** Write mode for writing a table. */
+export const enum WriteMode {
+  Create = 'Create',
+  Append = 'Append',
+  Overwrite = 'Overwrite'
+}
+/** Write options when creating a Table. */
+export interface WriteOptions {
+  /** Write mode for writing to a table. */
+  mode?: WriteMode
+}
+export interface OpenTableOptions {
+  storageOptions?: Record<string, string>
+}
+export class Connection {
+  /** Create a new Connection instance from the given URI. */
+  static new(uri: string, options: ConnectionOptions): Promise<Connection>
+  display(): string
+  isOpen(): boolean
+  close(): void
+  /** List all tables in the dataset. */
+  tableNames(startAfter?: string | undefined | null, limit?: number | undefined | null): Promise<Array<string>>
+  /**
+   * Create table from a Apache Arrow IPC (file) buffer.
+   *
+   * Parameters:
+   * - name: The name of the table.
+   * - buf: The buffer containing the IPC file.
+   *
+   */
+  createTable(name: string, buf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, useLegacyFormat?: boolean | undefined | null): Promise<Table>
+  createEmptyTable(name: string, schemaBuf: Buffer, mode: string, storageOptions?: Record<string, string> | undefined | null, useLegacyFormat?: boolean | undefined | null): Promise<Table>
+  openTable(name: string, storageOptions?: Record<string, string> | undefined | null, indexCacheSize?: number | undefined | null): Promise<Table>
+  /** Drop table with the name. Or raise an error if the table does not exist. */
+  dropTable(name: string): Promise<void>
+}
+export class Index {
+  static ivfPq(distanceType?: string | undefined | null, numPartitions?: number | undefined | null, numSubVectors?: number | undefined | null, maxIterations?: number | undefined | null, sampleRate?: number | undefined | null): Index
+  static btree(): Index
+}
+/** Typescript-style Async Iterator over RecordBatches  */
+export class RecordBatchIterator {
+  next(): Promise<Buffer | null>
+}
+/** A builder used to create and run a merge insert operation */
+export class NativeMergeInsertBuilder {
+  whenMatchedUpdateAll(condition?: string | undefined | null): NativeMergeInsertBuilder
+  whenNotMatchedInsertAll(): NativeMergeInsertBuilder
+  whenNotMatchedBySourceDelete(filter?: string | undefined | null): NativeMergeInsertBuilder
+  execute(buf: Buffer): Promise<void>
+}
+export class Query {
+  onlyIf(predicate: string): void
+  select(columns: Array<[string, string]>): void
+  limit(limit: number): void
+  nearestTo(vector: Float32Array): VectorQuery
+  execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
+  explainPlan(verbose: boolean): Promise<string>
+}
+export class VectorQuery {
+  column(column: string): void
+  distanceType(distanceType: string): void
+  postfilter(): void
+  refineFactor(refineFactor: number): void
+  nprobes(nprobe: number): void
+  bypassVectorIndex(): void
+  onlyIf(predicate: string): void
+  select(columns: Array<[string, string]>): void
+  limit(limit: number): void
+  execute(maxBatchLength?: number | undefined | null): Promise<RecordBatchIterator>
+  explainPlan(verbose: boolean): Promise<string>
+}
+export class Table {
+  name: string
+  display(): string
+  isOpen(): boolean
+  close(): void
+  /** Return Schema as empty Arrow IPC file. */
+  schema(): Promise<Buffer>
+  add(buf: Buffer, mode: string): Promise<void>
+  countRows(filter?: string | undefined | null): Promise<number>
+  delete(predicate: string): Promise<void>
+  createIndex(index: Index | undefined | null, column: string, replace?: boolean | undefined | null): Promise<void>
+  update(onlyIf: string | undefined | null, columns: Array<[string, string]>): Promise<void>
+  query(): Query
+  vectorSearch(vector: Float32Array): VectorQuery
+  addColumns(transforms: Array<AddColumnsSql>): Promise<void>
+  alterColumns(alterations: Array<ColumnAlteration>): Promise<void>
+  dropColumns(columns: Array<string>): Promise<void>
+  version(): Promise<number>
+  checkout(version: number): Promise<void>
+  checkoutLatest(): Promise<void>
+  restore(): Promise<void>
+  optimize(olderThanMs?: number | undefined | null): Promise<OptimizeStats>
+  listIndices(): Promise<Array<IndexConfig>>
+  indexStats(indexName: string): Promise<IndexStatistics | null>
+  mergeInsert(on: Array<string>): NativeMergeInsertBuilder
+}

package/nodejs-artifacts/arrow.d.ts

@@ -1,10 +1,43 @@
 /// <reference types="node" />
-import { Table as ArrowTable, Binary, DataType, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, Schema, Struct, Utf8 } from "apache-arrow";
+import { Table as ArrowTable, Binary, BufferType, DataType, Field, FixedSizeBinary, FixedSizeList, Float, Int, LargeBinary, List, Null, RecordBatch, Schema, Struct, Utf8 } from "apache-arrow";
+import { Buffers } from "apache-arrow/data";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
 export * from "apache-arrow";
-export type IntoVector = Float32Array | Float64Array | number[];
-export declare function isArrowTable(value: object): value is ArrowTable;
+export type SchemaLike = Schema | {
+    fields: FieldLike[];
+    metadata: Map<string, string>;
+    get names(): unknown[];
+};
+export type FieldLike = Field | {
+    type: string;
+    name: string;
+    nullable?: boolean;
+    metadata?: Map<string, string>;
+};
+export type DataLike = import("apache-arrow").Data<Struct<any>> | {
+    type: any;
+    length: number;
+    offset: number;
+    stride: number;
+    nullable: boolean;
+    children: DataLike[];
+    get nullCount(): number;
+    values: Buffers<any>[BufferType.DATA];
+    typeIds: Buffers<any>[BufferType.TYPE];
+    nullBitmap: Buffers<any>[BufferType.VALIDITY];
+    valueOffsets: Buffers<any>[BufferType.OFFSET];
+};
+export type RecordBatchLike = RecordBatch | {
+    schema: SchemaLike;
+    data: DataLike;
+};
+export type TableLike = ArrowTable | {
+    schema: SchemaLike;
+    batches: RecordBatchLike[];
+};
+export type IntoVector = Float32Array | Float64Array | number[] | Promise<Float32Array | Float64Array | number[]>;
+export declare function isArrowTable(value: object): value is TableLike;
 export declare function isDataType(value: unknown): value is DataType;
 export declare function isNull(value: unknown): value is Null;
 export declare function isInt(value: unknown): value is Int;
@@ -26,7 +59,7 @@ export declare function isUnion(value: unknown): value is Struct;
 export declare function isFixedSizeBinary(value: unknown): value is FixedSizeBinary;
 export declare function isFixedSizeList(value: unknown): value is FixedSizeList;
 /** Data type accepted by NodeJS SDK */
-export type Data = Record<string, unknown>[] | ArrowTable;
+export type Data = Record<string, unknown>[] | TableLike;
 export declare class VectorColumnOptions {
     /** Vector column type. */
     type: Float;
@@ -34,7 +67,7 @@ export declare class VectorColumnOptions {
 }
 /** Options to control the makeArrowTable call. */
 export declare class MakeArrowTableOptions {
-    schema?: Schema;
+    schema?: SchemaLike;
     vectorColumns: Record<string, VectorColumnOptions>;
     embeddings?: EmbeddingFunction<unknown>;
     embeddingFunction?: EmbeddingFunctionConfig;
@@ -146,7 +179,7 @@ export declare function makeArrowTable(data: Array<Record<string, unknown>>, opt
 /**
  * Create an empty Arrow table with the provided schema
  */
-export declare function makeEmptyTable(schema: Schema, metadata?: Map<string, string>): ArrowTable;
+export declare function makeEmptyTable(schema: SchemaLike, metadata?: Map<string, string>): ArrowTable;
 /**
  * Convert an Array of records into an Arrow Table, optionally applying an
  * embeddings function to it.
@@ -192,7 +225,7 @@ export declare function fromRecordsToStreamBuffer(data: Array<Record<string, unk
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Serialize an Arrow Table into a buffer using the Arrow IPC File serialization
  *
@@ -210,7 +243,7 @@ export declare function fromDataToBuffer(data: Data, embeddings?: EmbeddingFunct
  *
  * `schema` is required if the table is empty
  */
-export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: Schema): Promise<Buffer>;
+export declare function fromTableToStreamBuffer(table: ArrowTable, embeddings?: EmbeddingFunctionConfig, schema?: SchemaLike): Promise<Buffer>;
 /**
  * Create an empty table with the given schema
  */

package/nodejs-artifacts/arrow.js

@@ -505,15 +505,15 @@ async function applyEmbeddingsFromMetadata(table, schema) {
 }
 /** Helper function to apply embeddings to an input table */
 async function applyEmbeddings(table, embeddings, schema) {
+    if (schema !== undefined && schema !== null) {
+        schema = (0, sanitize_1.sanitizeSchema)(schema);
+    }
     if (schema?.metadata.has("embedding_functions")) {
         return applyEmbeddingsFromMetadata(table, schema);
     }
     else if (embeddings == null || embeddings === undefined) {
         return table;
     }
-    if (schema !== undefined && schema !== null) {
-        schema = (0, sanitize_1.sanitizeSchema)(schema);
-    }
     // Convert from ArrowTable to Record<String, Vector>
     const colEntries = [...Array(table.numCols).keys()].map((_, idx) => {
         const name = table.schema.fields[idx].name;
@@ -670,7 +670,7 @@ async function fromDataToBuffer(data, embeddings, schema) {
         schema = (0, sanitize_1.sanitizeSchema)(schema);
     }
     if (isArrowTable(data)) {
-        return fromTableToBuffer(data, embeddings, schema);
+        return fromTableToBuffer((0, sanitize_1.sanitizeTable)(data), embeddings, schema);
     }
     else {
         const table = await convertToTable(data, embeddings, { schema });

package/nodejs-artifacts/connection.d.ts

@@ -1,20 +1,7 @@
-import { Table as ArrowTable, Schema } from "./arrow";
+import { Data, SchemaLike, TableLike } from "./arrow";
 import { EmbeddingFunctionConfig } from "./embedding/registry";
-import { ConnectionOptions, Connection as LanceDbConnection } from "./native";
+import { Connection as LanceDbConnection } from "./native";
 import { Table } from "./table";
-/**
- * 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.
- */
-export declare function connect(uri: string, opts?: Partial<ConnectionOptions>): Promise<Connection>;
 export interface CreateTableOptions {
     /**
      * The mode to use when creating the table.
@@ -46,7 +33,7 @@ export interface CreateTableOptions {
      * The default is true while the new format is in beta
      */
     useLegacyFormat?: boolean;
-    schema?: Schema;
+    schema?: SchemaLike;
     embeddingFunction?: EmbeddingFunctionConfig;
 }
 export interface OpenTableOptions {
@@ -102,11 +89,11 @@ export interface TableNamesOptions {
  * Any created tables are independent and will continue to work even if
  * the underlying connection has been closed.
  */
-export declare class Connection {
-    readonly inner: LanceDbConnection;
-    constructor(inner: LanceDbConnection);
-    /** Return true if the connection has not been closed */
-    isOpen(): boolean;
+export declare abstract class Connection {
+    /**
+     * Return true if the connection has not been closed
+     */
+    abstract isOpen(): boolean;
     /**
      * Close the connection, releasing any underlying resources.
      *
@@ -114,38 +101,71 @@ export declare class Connection {
      *
      * Any attempt to use the connection after it is closed will result in an error.
      */
-    close(): void;
-    /** Return a brief description of the connection */
-    display(): string;
+    abstract close(): void;
+    /**
+     * Return a brief description of the connection
+     */
+    abstract display(): string;
     /**
      * List all the table names in this database.
      *
      * Tables will be returned in lexicographical order.
      * @param {Partial<TableNamesOptions>} options - options to control the
      * paging / start point
+     *
      */
-    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    abstract tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
     /**
      * Open a table in the database.
      * @param {string} name - The name of the table
      */
-    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    abstract openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    /**
+     * Creates a new Table and initialize it with new data.
+     * @param {object} options - The options object.
+     * @param {string} options.name - The name of the table.
+     * @param {Data} options.data - Non-empty Array of Records to be inserted into the table
+     *
+     */
+    abstract createTable(options: {
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new Table and initialize it with new data.
      * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
+     * @param {Record<string, unknown>[] | TableLike} data - Non-empty Array of Records
      * to be inserted into the table
      */
-    createTable(name: string, data: Record<string, unknown>[] | ArrowTable, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createTable(name: string, data: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Creates a new empty Table
      * @param {string} name - The name of the table.
      * @param {Schema} schema - The schema of the table
      */
-    createEmptyTable(name: string, schema: Schema, options?: Partial<CreateTableOptions>): Promise<Table>;
+    abstract createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     /**
      * Drop an existing table.
      * @param {string} name The name of the table to drop.
      */
+    abstract dropTable(name: string): Promise<void>;
+}
+export declare class LocalConnection extends Connection {
+    readonly inner: LanceDbConnection;
+    constructor(inner: LanceDbConnection);
+    isOpen(): boolean;
+    close(): void;
+    display(): string;
+    tableNames(options?: Partial<TableNamesOptions>): Promise<string[]>;
+    openTable(name: string, options?: Partial<OpenTableOptions>): Promise<Table>;
+    createTable(nameOrOptions: string | ({
+        name: string;
+        data: Data;
+    } & Partial<CreateTableOptions>), data?: Record<string, unknown>[] | TableLike, options?: Partial<CreateTableOptions>): Promise<Table>;
+    createEmptyTable(name: string, schema: import("./arrow").SchemaLike, options?: Partial<CreateTableOptions>): Promise<Table>;
     dropTable(name: string): Promise<void>;
 }
+/**
+ * Takes storage options and makes all the keys snake case.
+ */
+export declare function cleanseStorageOptions(options?: Record<string, string>): Record<string, string> | undefined;

package/nodejs-artifacts/connection.js

@@ -13,30 +13,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Connection = exports.connect = void 0;
+exports.cleanseStorageOptions = exports.LocalConnection = exports.Connection = void 0;
 const arrow_1 = require("./arrow");
 const registry_1 = require("./embedding/registry");
-const native_1 = require("./native");
 const table_1 = require("./table");
-/**
- * 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.
- */
-async function connect(uri, opts) {
-    opts = opts ?? {};
-    opts.storageOptions = cleanseStorageOptions(opts.storageOptions);
-    const nativeConn = await native_1.Connection.new(uri, opts);
-    return new Connection(nativeConn);
-}
-exports.connect = connect;
 /**
  * A LanceDB Connection that allows you to open tables and create new ones.
  *
@@ -56,74 +36,45 @@ exports.connect = connect;
  * the underlying connection has been closed.
  */
 class Connection {
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.display();
+    }
+}
+exports.Connection = Connection;
+class LocalConnection extends Connection {
     inner;
     constructor(inner) {
+        super();
         this.inner = inner;
     }
-    /** Return true if the connection has not been closed */
     isOpen() {
         return this.inner.isOpen();
     }
-    /**
-     * Close the connection, releasing any underlying resources.
-     *
-     * It is safe to call this method multiple times.
-     *
-     * Any attempt to use the connection after it is closed will result in an error.
-     */
     close() {
         this.inner.close();
     }
-    /** Return a brief description of the connection */
     display() {
         return this.inner.display();
     }
-    /**
-     * List all the table names in this database.
-     *
-     * Tables will be returned in lexicographical order.
-     * @param {Partial<TableNamesOptions>} options - options to control the
-     * paging / start point
-     */
     async tableNames(options) {
         return this.inner.tableNames(options?.startAfter, options?.limit);
     }
-    /**
-     * Open a table in the database.
-     * @param {string} name - The name of the table
-     */
     async openTable(name, options) {
         const innerTable = await this.inner.openTable(name, cleanseStorageOptions(options?.storageOptions), options?.indexCacheSize);
-        return new table_1.Table(innerTable);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new Table and initialize it with new data.
-     * @param {string} name - The name of the table.
-     * @param {Record<string, unknown>[] | ArrowTable} data - Non-empty Array of Records
-     * to be inserted into the table
-     */
-    async createTable(name, data, options) {
-        let mode = options?.mode ?? "create";
-        const existOk = options?.existOk ?? false;
-        if (mode === "create" && existOk) {
-            mode = "exist_ok";
-        }
-        let table;
-        if ((0, arrow_1.isArrowTable)(data)) {
-            table = data;
+    async createTable(nameOrOptions, data, options) {
+        if (typeof nameOrOptions !== "string" && "name" in nameOrOptions) {
+            const { name, data, ...options } = nameOrOptions;
+            return this.createTable(name, data, options);
         }
-        else {
-            table = (0, arrow_1.makeArrowTable)(data, options);
+        if (data === undefined) {
+            throw new Error("data is required");
         }
-        const buf = await (0, arrow_1.fromTableToBuffer)(table, options?.embeddingFunction, options?.schema);
-        const innerTable = await this.inner.createTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
-        return new table_1.Table(innerTable);
+        const { buf, mode } = await table_1.Table.parseTableData(data, options);
+        const innerTable = await this.inner.createTable(nameOrOptions, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Creates a new empty Table
-     * @param {string} name - The name of the table.
-     * @param {Schema} schema - The schema of the table
-     */
     async createEmptyTable(name, schema, options) {
         let mode = options?.mode ?? "create";
         const existOk = options?.existOk ?? false;
@@ -139,17 +90,13 @@ class Connection {
         const table = (0, arrow_1.makeEmptyTable)(schema, metadata);
         const buf = await (0, arrow_1.fromTableToBuffer)(table);
         const innerTable = await this.inner.createEmptyTable(name, buf, mode, cleanseStorageOptions(options?.storageOptions), options?.useLegacyFormat);
-        return new table_1.Table(innerTable);
+        return new table_1.LocalTable(innerTable);
     }
-    /**
-     * Drop an existing table.
-     * @param {string} name The name of the table to drop.
-     */
     async dropTable(name) {
         return this.inner.dropTable(name);
     }
 }
-exports.Connection = Connection;
+exports.LocalConnection = LocalConnection;
 /**
  * Takes storage options and makes all the keys snake case.
  */
@@ -166,6 +113,7 @@ function cleanseStorageOptions(options) {
     }
     return result;
 }
+exports.cleanseStorageOptions = cleanseStorageOptions;
 /**
  * Convert a string to snake case. It might already be snake case, in which case it is
  * returned unchanged.

package/nodejs-artifacts/embedding/embedding_function.d.ts

@@ -6,10 +6,18 @@ import { DataType, Float, type IntoVector } from "../arrow";
 export interface FunctionOptions {
     [key: string]: any;
 }
+export interface EmbeddingFunctionConstructor<T extends EmbeddingFunction = EmbeddingFunction> {
+    new (modelOptions?: T["TOptions"]): T;
+}
 /**
  * An embedding function that automatically creates vector representation for a given column.
  */
 export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptions = FunctionOptions> {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    readonly TOptions: M;
     /**
      * Convert the embedding function to a JSON object
      * It is used to serialize the embedding function to the schema
@@ -63,7 +71,7 @@ export declare abstract class EmbeddingFunction<T = any, M extends FunctionOptio
     /**
     Compute the embeddings for a single query
    */
-    computeQueryEmbeddings(data: T): Promise<IntoVector>;
+    computeQueryEmbeddings(data: T): Promise<Awaited<IntoVector>>;
 }
 export interface FieldOptions<T extends DataType = DataType> {
     datatype: T;

package/nodejs-artifacts/embedding/embedding_function.js

@@ -21,6 +21,12 @@ const sanitize_1 = require("../sanitize");
  * An embedding function that automatically creates vector representation for a given column.
  */
 class EmbeddingFunction {
+    /**
+     * @ignore
+     *  This is only used for associating the options type with the class for type checking
+     */
+    // biome-ignore lint/style/useNamingConvention: we want to keep the name as it is
+    TOptions;
     /**
      * sourceField is used in combination with `LanceSchema` to provide a declarative data model
      *

package/nodejs-artifacts/embedding/openai.d.ts

@@ -1,14 +1,15 @@
+import { type EmbeddingCreateParams } from "openai/resources";
 import { Float } from "../arrow";
 import { EmbeddingFunction } from "./embedding_function";
 export type OpenAIOptions = {
-    apiKey?: string;
-    model?: string;
+    apiKey: string;
+    model: EmbeddingCreateParams["model"];
 };
-export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, OpenAIOptions> {
+export declare class OpenAIEmbeddingFunction extends EmbeddingFunction<string, Partial<OpenAIOptions>> {
     #private;
-    constructor(options?: OpenAIOptions);
+    constructor(options?: Partial<OpenAIOptions>);
     toJSON(): {
-        model: string;
+        model: (string & {}) | "text-embedding-ada-002" | "text-embedding-3-small" | "text-embedding-3-large";
     };
     ndims(): number;
     embeddingDataType(): Float;