@lancedb/lancedb 0.4.20 → 0.5.0

package/README.md

@@ -43,29 +43,20 @@ npm run test
 
 ### Running lint / format
 
-LanceDb uses eslint for linting. VSCode does not need any plugins to use eslint. However, it
-may need some additional configuration. Make sure that eslint.experimental.useFlatConfig is
-set to true. Also, if your vscode root folder is the repo root then you will need to set
-the eslint.workingDirectories to ["nodejs"]. To manually lint your code you can run:
+LanceDb uses [biome](https://biomejs.dev/) for linting and formatting. if you are using VSCode you will need to install the official [Biome](https://marketplace.visualstudio.com/items?itemName=biomejs.biome) extension.
+To manually lint your code you can run:
 
 ```sh
 npm run lint
 ```
 
-LanceDb uses prettier for formatting. If you are using VSCode you will need to install the
-"Prettier - Code formatter" extension. You should then configure it to be the default formatter
-for typescript and you should enable format on save. To manually check your code's format you
-can run:
+to automatically fix all fixable issues:
 
 ```sh
-npm run chkformat
+npm run lint-fix
 ```
 
-If you need to manually format your code you can run:
-
-```sh
-npx prettier --write .
-```
+If you do not have your workspace root set to the `nodejs` directory, unfortunately the extension will not work. You can still run the linting and formatting commands manually.
 
 ### Generating docs
 

package/biome.json

@@ -0,0 +1,136 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.7.3/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "files": {
+    "ignore": [
+      "**/dist/**/*",
+      "**/native.js",
+      "**/native.d.ts",
+      "**/npm/**/*",
+      "**/.vscode/**"
+    ]
+  },
+  "formatter": {
+    "indentStyle": "space"
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": false,
+      "complexity": {
+        "noBannedTypes": "error",
+        "noExtraBooleanCast": "error",
+        "noMultipleSpacesInRegularExpressionLiterals": "error",
+        "noUselessCatch": "error",
+        "noUselessThisAlias": "error",
+        "noUselessTypeConstraint": "error",
+        "noWith": "error"
+      },
+      "correctness": {
+        "noConstAssign": "error",
+        "noConstantCondition": "error",
+        "noEmptyCharacterClassInRegex": "error",
+        "noEmptyPattern": "error",
+        "noGlobalObjectCalls": "error",
+        "noInnerDeclarations": "error",
+        "noInvalidConstructorSuper": "error",
+        "noNewSymbol": "error",
+        "noNonoctalDecimalEscape": "error",
+        "noPrecisionLoss": "error",
+        "noSelfAssign": "error",
+        "noSetterReturn": "error",
+        "noSwitchDeclarations": "error",
+        "noUndeclaredVariables": "error",
+        "noUnreachable": "error",
+        "noUnreachableSuper": "error",
+        "noUnsafeFinally": "error",
+        "noUnsafeOptionalChaining": "error",
+        "noUnusedLabels": "error",
+        "noUnusedVariables": "error",
+        "useIsNan": "error",
+        "useValidForDirection": "error",
+        "useYield": "error"
+      },
+      "style": {
+        "noNamespace": "error",
+        "useAsConstAssertion": "error",
+        "useBlockStatements": "off",
+        "useNamingConvention": {
+          "level": "error",
+          "options": {
+            "strictCase": false
+          }
+        }
+      },
+      "suspicious": {
+        "noAssignInExpressions": "error",
+        "noAsyncPromiseExecutor": "error",
+        "noCatchAssign": "error",
+        "noClassAssign": "error",
+        "noCompareNegZero": "error",
+        "noControlCharactersInRegex": "error",
+        "noDebugger": "error",
+        "noDuplicateCase": "error",
+        "noDuplicateClassMembers": "error",
+        "noDuplicateObjectKeys": "error",
+        "noDuplicateParameters": "error",
+        "noEmptyBlockStatements": "error",
+        "noExplicitAny": "error",
+        "noExtraNonNullAssertion": "error",
+        "noFallthroughSwitchClause": "error",
+        "noFunctionAssign": "error",
+        "noGlobalAssign": "error",
+        "noImportAssign": "error",
+        "noMisleadingCharacterClass": "error",
+        "noMisleadingInstantiator": "error",
+        "noPrototypeBuiltins": "error",
+        "noRedeclare": "error",
+        "noShadowRestrictedNames": "error",
+        "noUnsafeDeclarationMerging": "error",
+        "noUnsafeNegation": "error",
+        "useGetterReturn": "error",
+        "useValidTypeof": "error"
+      }
+    },
+    "ignore": ["**/dist/**/*", "**/native.js", "**/native.d.ts"]
+  },
+  "javascript": {
+    "globals": []
+  },
+  "overrides": [
+    {
+      "include": ["**/*.ts", "**/*.tsx", "**/*.mts", "**/*.cts"],
+      "linter": {
+        "rules": {
+          "correctness": {
+            "noConstAssign": "off",
+            "noGlobalObjectCalls": "off",
+            "noInvalidConstructorSuper": "off",
+            "noNewSymbol": "off",
+            "noSetterReturn": "off",
+            "noUndeclaredVariables": "off",
+            "noUnreachable": "off",
+            "noUnreachableSuper": "off"
+          },
+          "style": {
+            "noArguments": "error",
+            "noVar": "error",
+            "useConst": "error"
+          },
+          "suspicious": {
+            "noDuplicateClassMembers": "off",
+            "noDuplicateObjectKeys": "off",
+            "noDuplicateParameters": "off",
+            "noFunctionAssign": "off",
+            "noImportAssign": "off",
+            "noRedeclare": "off",
+            "noUnsafeNegation": "off",
+            "useGetterReturn": "off"
+          }
+        }
+      }
+    }
+  ]
+}

package/dist/arrow.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { type Schema, Table as ArrowTable, type Float } from "apache-arrow";
+import { Table as ArrowTable, type Float, Schema } from "apache-arrow";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 /** Data type accepted by NodeJS SDK */
 export type Data = Record<string, unknown>[] | ArrowTable;
@@ -12,6 +12,7 @@ export declare class VectorColumnOptions {
 export declare class MakeArrowTableOptions {
     schema?: Schema;
     vectorColumns: Record<string, VectorColumnOptions>;
+    embeddings?: EmbeddingFunction<unknown>;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *

package/dist/arrow.js

@@ -60,6 +60,7 @@ class MakeArrowTableOptions {
     vectorColumns = {
         vector: new VectorColumnOptions(),
     };
+    embeddings;
     /**
      * If true then string columns will be encoded with dictionary encoding
      *
@@ -175,6 +176,7 @@ function makeArrowTable(data, options) {
     const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
     if (opt.schema !== undefined && opt.schema !== null) {
         opt.schema = (0, sanitize_1.sanitizeSchema)(opt.schema);
+        opt.schema = validateSchemaEmbeddings(opt.schema, data, opt.embeddings);
     }
     const columns = {};
     // TODO: sample dataset to find missing columns
@@ -244,8 +246,9 @@ function makeArrowTable(data, options) {
         // then patch the schema of the batches so we can use
         // `new ArrowTable(schema, batches)` which does not do any schema inference
         const firstTable = new apache_arrow_1.Table(columns);
+        const batchesFixed = firstTable.batches.map(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const batchesFixed = firstTable.batches.map((batch) => new apache_arrow_1.RecordBatch(opt.schema, batch.data));
+        (batch) => new apache_arrow_1.RecordBatch(opt.schema, batch.data));
         return new apache_arrow_1.Table(opt.schema, batchesFixed);
     }
     else {
@@ -269,7 +272,7 @@ function makeListVector(lists) {
         throw Error("Cannot infer list vector from empty array or empty list");
     }
     const sampleList = lists[0];
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: skip
     let inferredType;
     try {
         const sampleVector = makeVector(sampleList);
@@ -537,3 +540,31 @@ function createEmptyTable(schema) {
     return new apache_arrow_1.Table((0, sanitize_1.sanitizeSchema)(schema));
 }
 exports.createEmptyTable = createEmptyTable;
+function validateSchemaEmbeddings(schema, data, embeddings) {
+    const fields = [];
+    const missingEmbeddingFields = [];
+    // First we check if the field is a `FixedSizeList`
+    // Then we check if the data contains the field
+    // if it does not, we add it to the list of missing embedding fields
+    // Finally, we check if those missing embedding fields are `this._embeddings`
+    // if they are not, we throw an error
+    for (const field of schema.fields) {
+        if (field.type instanceof apache_arrow_1.FixedSizeList) {
+            if (data.length !== 0 && data?.[0]?.[field.name] === undefined) {
+                missingEmbeddingFields.push(field);
+            }
+            else {
+                fields.push(field);
+            }
+        }
+        else {
+            fields.push(field);
+        }
+    }
+    if (missingEmbeddingFields.length > 0 && embeddings === undefined) {
+        throw new Error(`Table has embeddings: "${missingEmbeddingFields
+            .map((f) => f.name)
+            .join(",")}", but no embedding function was provided`);
+    }
+    return new apache_arrow_1.Schema(fields, schema.metadata);
+}

package/dist/connection.d.ts

@@ -1,6 +1,6 @@
+import { Table as ArrowTable, Schema } from "apache-arrow";
 import { ConnectionOptions, Connection as LanceDbConnection } from "./native";
 import { Table } from "./table";
-import { Table as ArrowTable, Schema } from "apache-arrow";
 /**
  * Connect to a LanceDB instance at the given URI.
  *

package/dist/connection.js

@@ -14,10 +14,10 @@
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Connection = exports.connect = void 0;
+const apache_arrow_1 = require("apache-arrow");
 const arrow_1 = require("./arrow");
 const native_1 = require("./native");
 const table_1 = require("./table");
-const apache_arrow_1 = require("apache-arrow");
 /**
  * Connect to a LanceDB instance at the given URI.
  *

package/dist/native.d.ts

@@ -15,6 +15,31 @@ export interface IndexConfig {
    */
   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,
@@ -151,5 +176,6 @@ export class Table {
   checkout(version: number): Promise<void>
   checkoutLatest(): Promise<void>
   restore(): Promise<void>
+  optimize(olderThanMs?: number | undefined | null): Promise<OptimizeStats>
   listIndices(): Promise<Array<IndexConfig>>
 }

package/dist/query.d.ts

@@ -1,4 +1,4 @@
-import { RecordBatch, Table as ArrowTable } from "apache-arrow";
+import { Table as ArrowTable, RecordBatch } from "apache-arrow";
 import { RecordBatchIterator as NativeBatchIterator, Query as NativeQuery, Table as NativeTable, VectorQuery as NativeVectorQuery } from "./native";
 export declare class RecordBatchIterator implements AsyncIterator<RecordBatch> {
     private promisedInner?;

package/dist/query.js

@@ -22,7 +22,7 @@ class RecordBatchIterator {
         // TODO: check promise reliably so we dont need to pass two arguments.
         this.promisedInner = promise;
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: skip
     async next() {
         if (this.inner === undefined) {
             this.inner = await this.promisedInner;
@@ -48,6 +48,7 @@ class QueryBase {
     inner;
     constructor(inner) {
         this.inner = inner;
+        // intentionally empty
     }
     /**
      * A filter statement to be applied to this query.
@@ -136,7 +137,7 @@ class QueryBase {
     execute() {
         return new RecordBatchIterator(this.nativeExecute());
     }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: skip
     [Symbol.asyncIterator]() {
         const promise = this.nativeExecute();
         return new RecordBatchIterator(promise);
@@ -338,7 +339,7 @@ class Query extends QueryBase {
      * a default `limit` of 10 will be used.  @see {@link Query#limit}
      */
     nearestTo(vector) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // biome-ignore lint/suspicious/noExplicitAny: skip
         const vectorQuery = this.inner.nearestTo(Float32Array.from(vector));
         return new VectorQuery(vectorQuery);
     }

package/dist/sanitize.js

@@ -127,7 +127,7 @@ function sanitizeUnion(typeLike) {
         throw Error("Expected a Union type to have an array-like `children` property");
     }
     return new apache_arrow_1.Union(typeLike.mode, 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: skip
     typeLike.typeIds, typeLike.children.map((child) => sanitizeField(child)));
 }
 function sanitizeTypedUnion(typeLike, 
@@ -167,7 +167,7 @@ function sanitizeMap(typeLike) {
         throw Error("Expected a Map type to have a `keysSorted` property");
     }
     return new apache_arrow_1.Map_(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // biome-ignore lint/suspicious/noExplicitAny: skip
     typeLike.children.map((field) => sanitizeField(field)), typeLike.keysSorted);
 }
 function sanitizeDuration(typeLike) {
@@ -191,7 +191,7 @@ function sanitizeDictionary(typeLike) {
     }
     return new apache_arrow_1.Dictionary(sanitizeType(typeLike.dictionary), sanitizeType(typeLike.indices), typeLike.id, typeLike.isOrdered);
 }
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+// biome-ignore lint/suspicious/noExplicitAny: skip
 function sanitizeType(typeLike) {
     if (typeof typeLike !== "object" || typeLike === null) {
         throw Error("Expected a Type but object was null/undefined");

package/dist/table.d.ts

@@ -1,8 +1,8 @@
 import { Schema } from "apache-arrow";
-import { AddColumnsSql, ColumnAlteration, IndexConfig, Table as _NativeTable } from "./native";
-import { Query, VectorQuery } from "./query";
-import { IndexOptions } from "./indices";
 import { Data } from "./arrow";
+import { IndexOptions } from "./indices";
+import { AddColumnsSql, ColumnAlteration, IndexConfig, OptimizeStats, Table as _NativeTable } from "./native";
+import { Query, VectorQuery } from "./query";
 export { IndexConfig } from "./native";
 /**
  * Options for adding data to a table.
@@ -28,6 +28,22 @@ export interface UpdateOptions {
      */
     where: string;
 }
+export interface OptimizeOptions {
+    /**
+     * If set then all versions older than the given date
+     * be removed.  The current version will never be removed.
+     * The default is 7 days
+     * @example
+     * // Delete all versions older than 1 day
+     * const olderThan = new Date();
+     * olderThan.setDate(olderThan.getDate() - 1));
+     * tbl.cleanupOlderVersions(olderThan);
+     *
+     * // Delete all versions except the current version
+     * tbl.cleanupOlderVersions(new Date());
+     */
+    cleanupOlderThan: Date;
+}
 /**
  * A Table is a collection of Records in a LanceDB Database.
  *
@@ -253,6 +269,37 @@ export declare class Table {
      * out state and the read_consistency_interval, if any, will apply.
      */
     restore(): Promise<void>;
+    /**
+     * Optimize the on-disk data and indices for better performance.
+     *
+     * Modeled after ``VACUUM`` in PostgreSQL.
+     *
+     *  Optimization covers three operations:
+     *
+     *  - Compaction: Merges small files into larger ones
+     *  - Prune: Removes old versions of the dataset
+     *  - Index: Optimizes the indices, adding new data to existing indices
+     *
+     *
+     *  Experimental API
+     *  ----------------
+     *
+     *  The optimization process is undergoing active development and may change.
+     *  Our goal with these changes is to improve the performance of optimization and
+     *  reduce the complexity.
+     *
+     *  That being said, it is essential today to run optimize if you want the best
+     *  performance.  It should be stable and safe to use in production, but it our
+     *  hope that the API may be simplified (or not even need to be called) in the
+     *  future.
+     *
+     *  The frequency an application shoudl call optimize is based on the frequency of
+     *  data modifications.  If data is frequently added, deleted, or updated then
+     *  optimize should be run frequently.  A good rule of thumb is to run optimize if
+     *  you have added or modified 100,000 or more records or run more than 20 data
+     *  modification operations.
+     */
+    optimize(options?: Partial<OptimizeOptions>): Promise<OptimizeStats>;
     /** List all indices that have been created with {@link Table.createIndex} */
     listIndices(): Promise<IndexConfig[]>;
 }

package/dist/table.js

@@ -15,8 +15,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Table = void 0;
 const apache_arrow_1 = require("apache-arrow");
-const query_1 = require("./query");
 const arrow_1 = require("./arrow");
+const query_1 = require("./query");
 /**
  * A Table is a collection of Records in a LanceDB Database.
  *
@@ -140,7 +140,7 @@ class Table {
      */
     async createIndex(column, options) {
         // Bit of a hack to get around the fact that TS has no package-scope.
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        // biome-ignore lint/suspicious/noExplicitAny: skip
         const nativeIndex = options?.config?.inner;
         await this.inner.createIndex(nativeIndex, column, options?.replace);
     }
@@ -296,6 +296,45 @@ class Table {
     async restore() {
         await this.inner.restore();
     }
+    /**
+     * Optimize the on-disk data and indices for better performance.
+     *
+     * Modeled after ``VACUUM`` in PostgreSQL.
+     *
+     *  Optimization covers three operations:
+     *
+     *  - Compaction: Merges small files into larger ones
+     *  - Prune: Removes old versions of the dataset
+     *  - Index: Optimizes the indices, adding new data to existing indices
+     *
+     *
+     *  Experimental API
+     *  ----------------
+     *
+     *  The optimization process is undergoing active development and may change.
+     *  Our goal with these changes is to improve the performance of optimization and
+     *  reduce the complexity.
+     *
+     *  That being said, it is essential today to run optimize if you want the best
+     *  performance.  It should be stable and safe to use in production, but it our
+     *  hope that the API may be simplified (or not even need to be called) in the
+     *  future.
+     *
+     *  The frequency an application shoudl call optimize is based on the frequency of
+     *  data modifications.  If data is frequently added, deleted, or updated then
+     *  optimize should be run frequently.  A good rule of thumb is to run optimize if
+     *  you have added or modified 100,000 or more records or run more than 20 data
+     *  modification operations.
+     */
+    async optimize(options) {
+        let cleanupOlderThanMs;
+        if (options?.cleanupOlderThan !== undefined &&
+            options?.cleanupOlderThan !== null) {
+            cleanupOlderThanMs =
+                new Date().getTime() - options.cleanupOlderThan.getTime();
+        }
+        return await this.inner.optimize(cleanupOlderThanMs);
+    }
     /** List all indices that have been created with {@link Table.createIndex} */
     async listIndices() {
         return await this.inner.listIndices();

package/lancedb/arrow.ts

@@ -13,25 +13,25 @@
 // limitations under the License.
 
 import {
+  Table as ArrowTable,
+  Binary,
+  DataType,
   Field,
-  makeBuilder,
-  RecordBatchFileWriter,
-  Utf8,
-  type Vector,
   FixedSizeList,
-  vectorFromArray,
-  type Schema,
-  Table as ArrowTable,
-  RecordBatchStreamWriter,
+  type Float,
+  Float32,
   List,
   RecordBatch,
-  makeData,
+  RecordBatchFileWriter,
+  RecordBatchStreamWriter,
+  Schema,
   Struct,
-  type Float,
-  DataType,
-  Binary,
-  Float32,
+  Utf8,
+  type Vector,
+  makeBuilder,
+  makeData,
   type makeTable,
+  vectorFromArray,
 } from "apache-arrow";
 import { type EmbeddingFunction } from "./embedding/embedding_function";
 import { sanitizeSchema } from "./sanitize";
@@ -85,6 +85,7 @@ export class MakeArrowTableOptions {
   vectorColumns: Record<string, VectorColumnOptions> = {
     vector: new VectorColumnOptions(),
   };
+  embeddings?: EmbeddingFunction<unknown>;
 
   /**
    * If true then string columns will be encoded with dictionary encoding
@@ -208,6 +209,7 @@ export function makeArrowTable(
   const opt = new MakeArrowTableOptions(options !== undefined ? options : {});
   if (opt.schema !== undefined && opt.schema !== null) {
     opt.schema = sanitizeSchema(opt.schema);
+    opt.schema = validateSchemaEmbeddings(opt.schema, data, opt.embeddings);
   }
   const columns: Record<string, Vector> = {};
   // TODO: sample dataset to find missing columns
@@ -287,8 +289,8 @@ export function makeArrowTable(
     // then patch the schema of the batches so we can use
     // `new ArrowTable(schema, batches)` which does not do any schema inference
     const firstTable = new ArrowTable(columns);
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
     const batchesFixed = firstTable.batches.map(
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
       (batch) => new RecordBatch(opt.schema!, batch.data),
     );
     return new ArrowTable(opt.schema, batchesFixed);
@@ -313,7 +315,7 @@ function makeListVector(lists: unknown[][]): Vector<unknown> {
     throw Error("Cannot infer list vector from empty array or empty list");
   }
   const sampleList = lists[0];
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // biome-ignore lint/suspicious/noExplicitAny: skip
   let inferredType: any;
   try {
     const sampleVector = makeVector(sampleList);
@@ -337,7 +339,7 @@ function makeVector(
   values: unknown[],
   type?: DataType,
   stringAsDictionary?: boolean,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  // biome-ignore lint/suspicious/noExplicitAny: skip
 ): Vector<any> {
   if (type !== undefined) {
     // No need for inference, let Arrow create it
@@ -648,3 +650,39 @@ function alignTable(table: ArrowTable, schema: Schema): ArrowTable {
 export function createEmptyTable(schema: Schema): ArrowTable {
   return new ArrowTable(sanitizeSchema(schema));
 }
+
+function validateSchemaEmbeddings(
+  schema: Schema,
+  data: Array<Record<string, unknown>>,
+  embeddings: EmbeddingFunction<unknown> | undefined,
+) {
+  const fields = [];
+  const missingEmbeddingFields = [];
+
+  // First we check if the field is a `FixedSizeList`
+  // Then we check if the data contains the field
+  // if it does not, we add it to the list of missing embedding fields
+  // Finally, we check if those missing embedding fields are `this._embeddings`
+  // if they are not, we throw an error
+  for (const field of schema.fields) {
+    if (field.type instanceof FixedSizeList) {
+      if (data.length !== 0 && data?.[0]?.[field.name] === undefined) {
+        missingEmbeddingFields.push(field);
+      } else {
+        fields.push(field);
+      }
+    } else {
+      fields.push(field);
+    }
+  }
+
+  if (missingEmbeddingFields.length > 0 && embeddings === undefined) {
+    throw new Error(
+      `Table has embeddings: "${missingEmbeddingFields
+        .map((f) => f.name)
+        .join(",")}", but no embedding function was provided`,
+    );
+  }
+
+  return new Schema(fields, schema.metadata);
+}

package/lancedb/connection.ts

@@ -12,10 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import { Table as ArrowTable, Schema } from "apache-arrow";
 import { fromTableToBuffer, makeArrowTable, makeEmptyTable } from "./arrow";
 import { ConnectionOptions, Connection as LanceDbConnection } from "./native";
 import { Table } from "./table";
-import { Table as ArrowTable, Schema } from "apache-arrow";
 
 /**
  * Connect to a LanceDB instance at the given URI.

package/lancedb/embedding/openai.ts

@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { type EmbeddingFunction } from "./embedding_function";
 import type OpenAI from "openai";
+import { type EmbeddingFunction } from "./embedding_function";
 
 export class OpenAIEmbeddingFunction implements EmbeddingFunction<string> {
   private readonly _openai: OpenAI;