npm - @infino-ai/infino - Versions diffs - 0.4.0 → 0.5.0 - Mend

@infino-ai/infino 0.4.0 → 0.5.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/infino/index.d.ts CHANGED Viewed

@@ -115,22 +115,16 @@ export interface VectorFilter {
     mode?: BoolMode;
 }
 export interface VectorSearchOptions {
-    /** IVF partitions to probe (higher = better recall, more work). */
-    nprobe?: number;
-    /** Over-fetch multiplier for the exact-rerank stage (higher = better recall). */
-    rerankMult?: number;
     projection?: string[];
     arrow?: boolean;
     /** Restrict the kNN to rows matching a text predicate (pushdown pre-filter). */
     filter?: VectorFilter;
 }
-/** Options for `hybridSearch`. `mode` applies to the BM25 side; `nprobe` to
- * the vector side. */
+/** Options for `hybridSearch`. `mode` applies to the BM25 side; vector
+ * probe width and rerank budget are engine-decided. */
 export interface HybridSearchOptions {
     /** BM25 boolean mode: `"or"` (default) or `"and"`. */
     mode?: BoolMode;
-    /** IVF partitions to probe on the vector side (higher = better recall). */
-    nprobe?: number;
     projection?: string[];
     arrow?: boolean;
 }
@@ -152,8 +146,9 @@ export interface QueryOptions {
 /** A table handle. Obtain one from {@link Connection.createTable} or {@link Connection.openTable}. */
 export declare class Table {
     private inner;
+    private remote;
     /** @hidden */
-    constructor(inner: any);
+    constructor(inner: any, remote?: boolean);
     /** The table's Arrow schema. */
     schema(): arrow.Schema;
     /**
@@ -224,8 +219,9 @@ export declare class Table {
 /** A catalog connection. Create one with {@link connect}. */
 export declare class Connection {
     private inner;
+    private remote;
     /** @hidden */
-    constructor(inner: any);
+    constructor(inner: any, remote?: boolean);
     /**
      * Provision the database this connection targets. On the hosted service this
      * registers the database (throws if it already exists); on a local backend the
@@ -254,7 +250,10 @@ export declare class Connection {
  * For a hosted (`https://`) target, authenticate with an API key: pass
  * {@link ConnectOptions.apiKey}, or set the `INFINO_API_KEY` environment
  * variable. Storage and cache tuning the URI can't carry also goes in
- * `options` (see {@link ConnectOptions}).
+ * `options` (see {@link ConnectOptions}). An operation failure the hosted
+ * API reported carries the HTTP status it returned as `status` on the
+ * thrown Error (`409` create conflict, `404` missing, `503` transient —
+ * retry with backoff); errors on local connections have no `status`.
  *
  * ```ts
  * // local

package/infino/index.js CHANGED Viewed

@@ -121,7 +121,10 @@ function schemaToIpc(schema) {
 // built by hand. The schema here is ours (from the addon), so its types
 // are same-instance.
 function buildColumn(field, rows) {
-    const values = rows.map((r) => r[field.name]);
+    // An omitted key reads as `undefined`, which `vectorFromArray` would
+    // coerce to the type's zero value (0, "", NaN, false) rather than null —
+    // its null set is `[null]` only. Normalize so omitted == explicit null.
+    const values = rows.map((r) => r[field.name] ?? null);
     const t = field.type;
     if (t && typeof t.listSize === "number") {
         const flat = Float32Array.from(values.flat());
@@ -189,17 +192,54 @@ function decode(buf, asArrow) {
         return obj;
     });
 }
+// --- hosted-API error status ---
+// The hosted transport types a few statuses before the number itself is
+// lost (the message keeps a stable prefix); every other HTTP failure it
+// reports as "<op>: server returned NNN: <body>". Both let the status be
+// recovered here. This table goes away once the transport carries the
+// status structurally.
+const PREFIX_STATUS = [
+    ["NotFound: ", 404],
+    ["AlreadyExists: ", 409],
+    ["ConflictError: ", 412],
+];
+const SERVER_STATUS = /\bserver returned (\d{3}): /;
+/**
+ * Run a native call. On a hosted (Infino Cloud) connection, a failure is
+ * rethrown as-is but tagged with `status` — the HTTP status the API
+ * actually returned — so callers can branch (e.g. `409` = already exists,
+ * `503` = transient, retry) without parsing message text. Local
+ * connections rethrow untouched.
+ */
+function guard(remote, fn) {
+    if (!remote)
+        return fn();
+    try {
+        return fn();
+    }
+    catch (e) {
+        if (e instanceof Error && e.status === undefined) {
+            const prefixed = PREFIX_STATUS.find(([prefix]) => e.message.startsWith(prefix));
+            const status = prefixed ? prefixed[1] : Number(SERVER_STATUS.exec(e.message)?.[1]);
+            if (Number.isFinite(status))
+                e.status = status;
+        }
+        throw e;
+    }
+}
 // --- friendly handles ---
 /** A table handle. Obtain one from {@link Connection.createTable} or {@link Connection.openTable}. */
 class Table {
     inner;
+    remote;
     /** @hidden */
-    constructor(inner) {
+    constructor(inner, remote = false) {
         this.inner = inner;
+        this.remote = remote;
     }
     /** The table's Arrow schema. */
     schema() {
-        return arrow.tableFromIPC(this.inner.schema()).schema;
+        return arrow.tableFromIPC(guard(this.remote, () => this.inner.schema())).schema;
     }
     /**
      * Append rows. Accepts an array of objects, an apache-arrow
@@ -207,45 +247,47 @@ class Table {
      * append == one commit.
      */
     append(data) {
-        this.inner.append(dataToIpc(data, () => this.schema()));
+        const ipc = dataToIpc(data, () => this.schema());
+        guard(this.remote, () => this.inner.append(ipc));
     }
     bm25Search(column, query, k, opts = {}) {
-        const buf = this.inner.bm25Search(column, query, k, opts.mode, opts.stats, opts.projection);
+        const buf = guard(this.remote, () => this.inner.bm25Search(column, query, k, opts.mode, opts.stats, opts.projection));
         return decode(buf, opts.arrow);
     }
     vectorSearch(column, query, k, opts = {}) {
         const q = query instanceof Float32Array ? query : Float32Array.from(query);
-        const buf = this.inner.vectorSearch(column, q, k, opts.nprobe, opts.rerankMult, opts.projection, opts.filter);
+        const buf = guard(this.remote, () => this.inner.vectorSearch(column, q, k, opts.projection, opts.filter));
         return decode(buf, opts.arrow);
     }
     hybridSearch(textColumn, textQuery, vectorColumn, vectorQuery, k, opts = {}) {
         const q = vectorQuery instanceof Float32Array ? vectorQuery : Float32Array.from(vectorQuery);
-        const buf = this.inner.hybridSearch(textColumn, textQuery, vectorColumn, q, k, opts.mode, opts.nprobe, opts.projection);
+        const buf = guard(this.remote, () => this.inner.hybridSearch(textColumn, textQuery, vectorColumn, q, k, opts.mode, opts.projection));
         return decode(buf, opts.arrow);
     }
     tokenMatch(column, query, opts = {}) {
-        const buf = this.inner.tokenMatch(column, query, opts.mode, opts.projection);
+        const buf = guard(this.remote, () => this.inner.tokenMatch(column, query, opts.mode, opts.projection));
         return decode(buf, opts.arrow);
     }
     exactMatch(column, value, opts = {}) {
-        const buf = this.inner.exactMatch(column, value, opts.projection);
+        const buf = guard(this.remote, () => this.inner.exactMatch(column, value, opts.projection));
         return decode(buf, opts.arrow);
     }
     /** Count rows matching a BM25 keyword `query` over `column`, without
      * fetching them. `mode` is `"or"` (default) or `"and"`. */
     count(column, query, opts = {}) {
-        return this.inner.count(column, query, opts.mode);
+        return guard(this.remote, () => this.inner.count(column, query, opts.mode));
     }
     /** Replace rows matching a SQL predicate (e.g. `"status = 'spam'"`) with
      * `data` (same shapes as `append`), 1:1 — the matched count must equal the
      * replacement-row count. Requires durable storage (not `memory://`). */
     update(predicate, data) {
-        return this.inner.update(predicate, dataToIpc(data, () => this.schema()));
+        const ipc = dataToIpc(data, () => this.schema());
+        return guard(this.remote, () => this.inner.update(predicate, ipc));
     }
     /** Delete rows matching a SQL predicate (e.g. `"status = 'spam'"`).
      * Requires durable storage (not `memory://`). */
     delete(predicate) {
-        return this.inner.delete(predicate);
+        return guard(this.remote, () => this.inner.delete(predicate));
     }
     /**
      * Merge small / underfilled superfiles into larger ones (omit `settings`
@@ -255,7 +297,7 @@ class Table {
      * so calling this on a hosted (`https://…`) connection throws.
      */
     optimize(settings) {
-        this.inner.optimize(settings);
+        guard(this.remote, () => this.inner.optimize(settings));
     }
     /**
      * Delete orphaned storage objects left by compaction or interrupted writes.
@@ -266,16 +308,18 @@ class Table {
      * calling this on a hosted connection throws.
      */
     gc(graceSecs) {
-        return this.inner.gc(graceSecs);
+        return guard(this.remote, () => this.inner.gc(graceSecs));
     }
 }
 exports.Table = Table;
 /** A catalog connection. Create one with {@link connect}. */
 class Connection {
     inner;
+    remote;
     /** @hidden */
-    constructor(inner) {
+    constructor(inner, remote = false) {
         this.inner = inner;
+        this.remote = remote;
     }
     /**
      * Provision the database this connection targets. On the hosted service this
@@ -283,23 +327,24 @@ class Connection {
      * catalog root is the database, so it is a no-op success.
      */
     createDatabase() {
-        this.inner.createDatabase();
+        guard(this.remote, () => this.inner.createDatabase());
     }
     /** Create a table from an apache-arrow `Schema` or `{ column: type }`. */
     createTable(name, schema, indexes) {
-        return new Table(this.inner.createTable(name, schemaToIpc(schema), indexes));
+        const ipc = schemaToIpc(schema);
+        return new Table(guard(this.remote, () => this.inner.createTable(name, ipc, indexes)), this.remote);
     }
     openTable(name) {
-        return new Table(this.inner.openTable(name));
+        return new Table(guard(this.remote, () => this.inner.openTable(name)), this.remote);
     }
     dropTable(name, purge) {
-        this.inner.dropTable(name, purge);
+        guard(this.remote, () => this.inner.dropTable(name, purge));
     }
     listTables() {
-        return this.inner.listTables();
+        return guard(this.remote, () => this.inner.listTables());
     }
     querySql(sql, opts = {}) {
-        return decode(this.inner.querySql(sql), opts.arrow);
+        return decode(guard(this.remote, () => this.inner.querySql(sql)), opts.arrow);
     }
 }
 exports.Connection = Connection;
@@ -314,7 +359,10 @@ exports.Connection = Connection;
  * For a hosted (`https://`) target, authenticate with an API key: pass
  * {@link ConnectOptions.apiKey}, or set the `INFINO_API_KEY` environment
  * variable. Storage and cache tuning the URI can't carry also goes in
- * `options` (see {@link ConnectOptions}).
+ * `options` (see {@link ConnectOptions}). An operation failure the hosted
+ * API reported carries the HTTP status it returned as `status` on the
+ * thrown Error (`409` create conflict, `404` missing, `503` transient —
+ * retry with backoff); errors on local connections have no `status`.
  *
  * ```ts
  * // local
@@ -324,5 +372,6 @@ exports.Connection = Connection;
  * ```
  */
 function connect(uri, options) {
-    return new Connection((0, native_js_1.connect)(uri, options));
+    const remote = /^https?:\/\//.test(uri);
+    return new Connection(guard(remote, () => (0, native_js_1.connect)(uri, options)), remote);
 }

package/infino/native.d.ts CHANGED Viewed

@@ -175,7 +175,7 @@ export declare class Table {
    * opposite direction from `bm25Search`'s similarity. Fuse with
    * `hybridSearch`.
    */
-  vectorSearch(column: string, query: Float32Array, k: number, nprobe?: number | undefined | null, rerankMult?: number | undefined | null, projection?: Array<string> | undefined | null, filter?: VectorFilter | undefined | null): Buffer
+  vectorSearch(column: string, query: Float32Array, k: number, projection?: Array<string> | undefined | null, filter?: VectorFilter | undefined | null): Buffer
   /**
    * Unranked token match over one FTS column — every row whose `column`
    * matches the query's tokens under `mode` (`"or"` default, `"and"`).
@@ -197,11 +197,12 @@ export declare class Table {
   /**
    * Hybrid BM25 + vector search fused with reciprocal-rank fusion.
    * `text_column`/`text_query` (under `mode`) drive BM25; `vector_column`/
-   * `vector_query` (a `Float32Array`, with optional `nprobe`) drive vector
-   * kNN. Returns Arrow rows like [`Table::bm25_search`], with `score` the
-   * fused RRF score (higher is better); `projection` selects columns.
+   * `vector_query` (a `Float32Array`) drive vector kNN — probe width and
+   * rerank budget are engine-decided. Returns Arrow rows like
+   * [`Table::bm25_search`], with `score` the fused RRF score (higher is
+   * better); `projection` selects columns.
    */
-  hybridSearch(textColumn: string, textQuery: string, vectorColumn: string, vectorQuery: Float32Array, k: number, mode?: string | undefined | null, nprobe?: number | undefined | null, projection?: Array<string> | undefined | null): Buffer
+  hybridSearch(textColumn: string, textQuery: string, vectorColumn: string, vectorQuery: Float32Array, k: number, mode?: string | undefined | null, projection?: Array<string> | undefined | null): Buffer
   /**
    * Delete every row matching a SQL `predicate` (e.g. `"status = 'spam'"`),
    * returning the mutation counts. Requires durable storage — a `memory://`

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@infino-ai/infino",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Fast search on object storage — SQL, full-text, and vector search.",
   "license": "Apache-2.0",
   "publishConfig": {
@@ -82,12 +82,12 @@
     "apache-arrow": "^17"
   },
   "optionalDependencies": {
-    "infx-darwin-x64": "0.4.0",
-    "infx-darwin-arm64": "0.4.0",
-    "infx-linux-x64-gnu": "0.4.0",
-    "infx-linux-arm64-gnu": "0.4.0",
-    "infx-linux-x64-musl": "0.4.0",
-    "infx-linux-arm64-musl": "0.4.0"
+    "infx-darwin-x64": "0.5.0",
+    "infx-darwin-arm64": "0.5.0",
+    "infx-linux-x64-gnu": "0.5.0",
+    "infx-linux-arm64-gnu": "0.5.0",
+    "infx-linux-x64-musl": "0.5.0",
+    "infx-linux-arm64-musl": "0.5.0"
   },
   "devDependencies": {
     "@napi-rs/cli": "^2.18.0",