@uwdata/mosaic-core 0.10.0 → 0.11.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-core",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "Scalable and extensible linked data views.",
   "keywords": [
     "mosaic",
@@ -24,16 +24,16 @@
     "prebuild": "rimraf dist && mkdir dist",
     "build": "node ../../esbuild.js mosaic-core",
     "lint": "eslint src test",
-    "test": "mocha 'test/**/*-test.js'",
+    "test": "vitest run --dangerouslyIgnoreUnhandledErrors",
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
   "dependencies": {
-    "@duckdb/duckdb-wasm": "^1.28.1-dev232.0",
-    "@uwdata/mosaic-sql": "^0.10.0",
-    "apache-arrow": "^16.1.0"
+    "@duckdb/duckdb-wasm": "^1.28.1-dev278.0",
+    "@uwdata/flechette": "^1.0.2",
+    "@uwdata/mosaic-sql": "^0.11.0"
   },
   "devDependencies": {
-    "@uwdata/mosaic-duckdb": "^0.10.0"
+    "@uwdata/mosaic-duckdb": "^0.11.0"
   },
-  "gitHead": "94fc4f0d4efc622001f6afd6714d1e9dda745be2"
+  "gitHead": "861d616f39926a1d2aee83b59dbdd70b0b3caf12"
 }

package/src/Coordinator.js

@@ -1,7 +1,9 @@
 import { socketConnector } from './connectors/socket.js';
 import { DataCubeIndexer } from './DataCubeIndexer.js';
+import { MosaicClient } from './MosaicClient.js';
 import { QueryManager, Priority } from './QueryManager.js';
 import { queryFieldInfo } from './util/field-info.js';
+import { QueryResult } from './util/query-result.js';
 import { voidLogger } from './util/void-logger.js';
 
 /**
@@ -24,6 +26,10 @@ export function coordinator(instance) {
   return _instance;
 }
 
+/**
+ * @typedef {import('@uwdata/mosaic-sql').Query | string} QueryType
+ */
+
 /**
  * A Mosaic Coordinator manages all database communication for clients and
  * handles selection updates. The Coordinator also performs optimizations
@@ -34,7 +40,8 @@ export function coordinator(instance) {
  * @param {*} [options.manager] The query manager to use.
  * @param {boolean} [options.cache=true] Boolean flag to enable/disable query caching.
  * @param {boolean} [options.consolidate=true] Boolean flag to enable/disable query consolidation.
- * @param {object} [options.indexes] Data cube indexer options.
+ * @param {import('./DataCubeIndexer.js').DataCubeIndexerOptions} [options.indexes]
+ *  Data cube indexer options.
  */
 export class Coordinator {
   constructor(db = socketConnector(), {
@@ -44,13 +51,14 @@ export class Coordinator {
     consolidate = true,
     indexes = {}
   } = {}) {
+    /** @type {QueryManager} */
     this.manager = manager;
     this.manager.cache(cache);
     this.manager.consolidate(consolidate);
-    this.dataCubeIndexer = new DataCubeIndexer(this, indexes);
-    this.logger(logger);
     this.databaseConnector(db);
+    this.logger(logger);
     this.clear();
+    this.dataCubeIndexer = new DataCubeIndexer(this, indexes);
   }
 
   /**
@@ -97,7 +105,7 @@ export class Coordinator {
   /**
    * Cancel previosuly submitted query requests. These queries will be
    * canceled if they are queued but have not yet been submitted.
-   * @param {import('./util/query-result.js').QueryResult[]} requests An array
+   * @param {QueryResult[]} requests An array
    *  of query result objects, such as those returned by the `query` method.
    */
   cancel(requests) {
@@ -106,29 +114,30 @@ export class Coordinator {
 
   /**
    * Issue a query for which no result (return value) is needed.
-   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {QueryType | QueryType[]} query The query or an array of queries.
+   *  Each query should be either a Query builder object or a SQL string.
    * @param {object} [options] An options object.
    * @param {number} [options.priority] The query priority, defaults to
    *  `Priority.Normal`.
-   * @returns {import('./util/query-result.js').QueryResult} A query result
+   * @returns {QueryResult} A query result
    *  promise.
    */
   exec(query, { priority = Priority.Normal } = {}) {
-    query = Array.isArray(query) ? query.join(';\n') : query;
+    query = Array.isArray(query) ? query.filter(x => x).join(';\n') : query;
     return this.manager.request({ type: 'exec', query }, priority);
   }
 
   /**
    * Issue a query to the backing database. The submitted query may be
    * consolidate with other queries and its results may be cached.
-   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {QueryType} query The query as either a Query builder object
+   *  or a SQL string.
    * @param {object} [options] An options object.
    * @param {'arrow' | 'json'} [options.type] The query result format type.
    * @param {boolean} [options.cache=true] If true, cache the query result.
    * @param {number} [options.priority] The query priority, defaults to
    *  `Priority.Normal`.
-   * @returns {import('./util/query-result.js').QueryResult} A query result
-   *  promise.
+   * @returns {QueryResult} A query result promise.
    */
   query(query, {
     type = 'arrow',
@@ -142,21 +151,35 @@ export class Coordinator {
   /**
    * Issue a query to prefetch data for later use. The query result is cached
    * for efficient future access.
-   * @param {import('@uwdata/mosaic-sql').Query | string} query The query.
+   * @param {QueryType} query The query as either a Query builder object
+   *  or a SQL string.
    * @param {object} [options] An options object.
    * @param {'arrow' | 'json'} [options.type] The query result format type.
-   * @returns {import('./util/query-result.js').QueryResult} A query result
-   *  promise.
+   * @returns {QueryResult} A query result promise.
    */
   prefetch(query, options = {}) {
     return this.query(query, { ...options, cache: true, priority: Priority.Low });
   }
 
+  /**
+   * Create a bundle of queries that can be loaded into the cache.
+   *
+   * @param {string} name The name of the bundle.
+   * @param {[string | {sql: string},  {alias: string}]} queries The queries to save into the bundle.
+   * @param {number} priority Request priority.
+   * @returns {QueryResult} A query result promise.
+   */
   createBundle(name, queries, priority = Priority.Low) {
-    const options = { name, queries };
+    const options = { name, queries: queries.map(q => typeof q == 'string' ? {sql: q} : q) };
     return this.manager.request({ type: 'create-bundle', options }, priority);
   }
 
+  /**
+   * Load a bundle into the cache.
+   * @param {string} name The name of the bundle.
+   * @param {number} priority Request priority.
+   * @returns {QueryResult} A query result promise.
+   */
   loadBundle(name, priority = Priority.High) {
     const options = { name };
     return this.manager.request({ type: 'load-bundle', options }, priority);
@@ -167,8 +190,8 @@ export class Coordinator {
   /**
    * Update client data by submitting the given query and returning the
    * data (or error) to the client.
-   * @param {import('./MosaicClient.js').MosaicClient} client A Mosaic client.
-   * @param {import('@uwdata/mosaic-sql').Query | string} query The data query.
+   * @param {MosaicClient} client A Mosaic client.
+   * @param {QueryType} query The data query.
    * @param {number} [priority] The query priority.
    * @returns {Promise} A Promise that resolves upon completion of the update.
    */
@@ -186,22 +209,19 @@ export class Coordinator {
    * Issue a query request for a client. If the query is null or undefined,
    * the client is simply updated. Otherwise `updateClient` is called. As a
    * side effect, this method clears the current data cube indexer state.
-   * @param {import('./MosaicClient.js').MosaicClient} client The client
-   *  to update.
-   * @param {import('@uwdata/mosaic-sql').Query | string | null} [query]
-   *  The query to issue.
+   * @param {MosaicClient} client The client to update.
+   * @param {QueryType | null} [query] The query to issue.
    */
   requestQuery(client, query) {
     this.dataCubeIndexer.clear();
     return query
       ? this.updateClient(client, query)
-      : client.update();
+      : Promise.resolve(client.update());
   }
 
   /**
    * Connect a client to the coordinator.
-   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
-   *  client to connect.
+   * @param {MosaicClient} client The Mosaic client to connect.
    */
   async connect(client) {
     const { clients } = this;
@@ -212,22 +232,27 @@ export class Coordinator {
     clients.add(client); // mark as connected
     client.coordinator = this;
 
+    // initialize client lifecycle
+    this.initializeClient(client);
+
+    // connect filter selection
+    connectSelection(this, client.filterBy, client);
+  }
+
+  async initializeClient(client) {
     // retrieve field statistics
     const fields = client.fields();
     if (fields?.length) {
       client.fieldInfo(await queryFieldInfo(this, fields));
     }
 
-    // connect filter selection
-    connectSelection(this, client.filterBy, client);
-
-    client.requestQuery();
+    // request data query
+    return client.requestQuery();
   }
 
   /**
    * Disconnect a client from the coordinator.
-   * @param {import('./MosaicClient.js').MosaicClient} client The Mosaic
-   *  client to disconnect.
+   * @param {MosaicClient} client The Mosaic client to disconnect.
    */
   disconnect(client) {
     const { clients, filterGroups } = this;
@@ -246,8 +271,8 @@ export class Coordinator {
  * Connect a selection-client pair to the coordinator to process updates.
  * @param {Coordinator} mc The Mosaic coordinator.
  * @param {import('./Selection.js').Selection} selection A selection.
- * @param {import('./MosaicClient.js').MosaicClient} client A Mosiac
- *  client that is filtered by the given selection.
+ * @param {MosaicClient} client A Mosiac client that is filtered by the
+ *  given selection.
  */
 function connectSelection(mc, selection, client) {
   if (!selection) return;

package/src/DataCubeIndexer.js

@@ -6,59 +6,114 @@ import { fnv_hash } from './util/hash.js';
 
 const Skip = { skip: true, result: null };
 
+/**
+ * @typedef {object} DataCubeIndexerOptions
+ * @property {string} [schema] Database schema (namespace) in which to write
+ *  data cube index tables (default 'mosaic').
+ * @property {boolean} [options.enabled=true] Flag to enable or disable the
+ *  indexer. This setting can later be updated via the `enabled` method.
+ */
+
 /**
  * Build and query optimized indices ("data cubes") for fast computation of
  * groupby aggregate queries over compatible client queries and selections.
  * A data cube contains pre-aggregated data for a Mosaic client, subdivided
  * by possible query values from an active selection clause. These cubes are
  * realized as as database tables that can be queried for rapid updates.
+ *
  * Compatible client queries must consist of only groupby dimensions and
  * supported aggregate functions. Compatible selections must contain an active
  * clause that exposes metadata for an interval or point value predicate.
+ *
+ * Data cube index tables are written to a dedicated schema (namespace) that
+ * can be set using the *schema* constructor option. This schema acts as a
+ * persistent cache, and index tables may be used across sessions. The
+ * `dropIndexTables` method issues a query to remove *all* tables within
+ * this schema. This may be needed if the original tables have updated data,
+ * but should be used with care.
  */
 export class DataCubeIndexer {
   /**
    * Create a new data cube index table manager.
    * @param {import('./Coordinator.js').Coordinator} coordinator A Mosaic coordinator.
-   * @param {object} [options] Indexer options.
-   * @param {boolean} [options.enabled=true] Flag to enable/disable indexer.
-   * @param {boolean} [options.temp=true] Flag to indicate if generated data
-   *  cube index tables should be temporary tables.
+   * @param {DataCubeIndexerOptions} [options] Data cube indexer options.
    */
   constructor(coordinator, {
-    enabled = true,
-    temp = true
+    schema = 'mosaic',
+    enabled = true
   } = {}) {
     /** @type {Map<import('./MosaicClient.js').MosaicClient, DataCubeInfo | Skip | null>} */
     this.indexes = new Map();
     this.active = null;
-    this.temp = temp;
     this.mc = coordinator;
+    this._schema = schema;
     this._enabled = enabled;
   }
 
   /**
-   * Set the enabled state of this indexer. If false, any cached state is
+   * Set the enabled state of this indexer. If false, any local state is
    * cleared and subsequent index calls will return null until re-enabled.
-   * @param {boolean} state The enabled state.
+   * This method has no effect on any index tables already in the database.
+   * @param {boolean} [state] The enabled state to set.
    */
-  enabled(state) {
-    if (state === undefined) {
-      return this._enabled;
-    } else if (this._enabled !== state) {
+  set enabled(state) {
+    if (this._enabled !== state) {
       if (!state) this.clear();
       this._enabled = state;
     }
   }
 
+  /**
+   * Get the enabled state of this indexer.
+   * @returns {boolean} The current enabled state.
+   */
+  get enabled() {
+    return this._enabled;
+  }
+
+  /**
+   * Set the database schema used by this indexer. Upon changes, any local
+   * state is cleared. This method does _not_ drop any existing data cube
+   * tables, use `dropIndexTables` before changing the schema to also remove
+   * existing index tables in the database.
+   * @param {string} [schema] The schema name to set.
+   */
+  set schema(schema) {
+    if (this._schema !== schema) {
+      this.clear();
+      this._schema = schema;
+    }
+  }
+
+  /**
+   * Get the database schema used by this indexer.
+   * @returns {string} The current schema name.
+   */
+  get schema() {
+    return this._schema;
+  }
+
+  /**
+   * Issues a query through the coordinator to drop the current index table
+   * schema. *All* tables in the schema will be removed and local state is
+   * cleared. Call this method if the underlying base tables have been updated,
+   * causing derived index tables to become stale and inaccurate. Use this
+   * method with care! Once dropped, the schema will be repopulated by future
+   * data cube indexer requests.
+   * @returns A query result promise.
+   */
+  dropIndexTables() {
+    this.clear();
+    return this.mc.exec(`DROP SCHEMA IF EXISTS "${this.schema}" CASCADE`);
+  }
+
   /**
    * Clear the cache of data cube index table entries for the current active
-   * selection clause. This method will also cancel any queued data cube table
-   * creation queries that have not yet been submitted to the database. This
-   * method does _not_ drop any existing data cube tables.
+   * selection clause. This method does _not_ drop any existing data cube
+   * tables. Use `dropIndexTables` to remove existing index tables from the
+   * database.
    */
   clear() {
-    this.mc.cancel(Array.from(this.indexes.values(), info => info?.result));
     this.indexes.clear();
     this.active = null;
   }
@@ -79,9 +134,9 @@ export class DataCubeIndexer {
    */
   index(client, selection, activeClause) {
     // if not enabled, do nothing
-    if (!this._enabled) return null;
+    if (!this.enabled) return null;
 
-    const { indexes, mc, temp } = this;
+    const { indexes, mc, schema } = this;
     const { source } = activeClause;
 
     // if there is no clause source to track, do nothing
@@ -127,8 +182,11 @@ export class DataCubeIndexer {
     } else {
       // generate data cube index table
       const filter = selection.remove(source).predicate(client);
-      info = dataCubeInfo(client.query(filter), active, indexCols);
-      info.result = mc.exec(create(info.table, info.create, { temp }));
+      info = dataCubeInfo(client.query(filter), active, indexCols, schema);
+      info.result = mc.exec([
+        `CREATE SCHEMA IF NOT EXISTS ${schema}`,
+        create(info.table, info.create, { temp: false })
+      ]);
       info.result.catch(e => mc.logger().error(e));
     }
 
@@ -225,7 +283,7 @@ function binInterval(scale, pixelSize, bin) {
  * @param {*} indexCols Data cube index column definitions.
  * @returns {DataCubeInfo}
  */
-function dataCubeInfo(clientQuery, active, indexCols) {
+function dataCubeInfo(clientQuery, active, indexCols, schema) {
   const { dims, aggr, aux } = indexCols;
   const { columns } = active;
 
@@ -248,7 +306,7 @@ function dataCubeInfo(clientQuery, active, indexCols) {
   // generate creation query string and hash id
   const create = query.toString();
   const id = (fnv_hash(create) >>> 0).toString(16);
-  const table = `cube_index_${id}`;
+  const table = `${schema}.cube_${id}`;
 
   // generate data cube select query
   const select = Query
@@ -257,7 +315,7 @@ function dataCubeInfo(clientQuery, active, indexCols) {
     .groupby(dims)
     .orderby(order);
 
-  return new DataCubeInfo({ table, create, active, select });
+  return new DataCubeInfo({ id, table, create, active, select });
 }
 
 /**

package/src/MosaicClient.js

@@ -103,6 +103,7 @@ export class MosaicClient {
    * Request the coordinator to execute a query for this client.
    * If an explicit query is not provided, the client query method will
    * be called, filtered by the current filterBy selection.
+   * @returns {Promise}
    */
   requestQuery(query) {
     const q = query || this.query(this.filterBy?.predicate(this));
@@ -119,6 +120,14 @@ export class MosaicClient {
     this._requestUpdate();
   }
 
+  /**
+   * Reset this client, initiating new field info and query requests.
+   * @returns {Promise}
+   */
+  initialize() {
+    return this._coordinator.initializeClient(this);
+  }
+
   /**
    * Requests a client update.
    * For example to (re-)render an interface component.

package/src/QueryConsolidator.js

@@ -108,6 +108,12 @@ function consolidationKey(query, cache) {
       // @ts-ignore
       q.$groupby(groupby.map(e => (e instanceof Ref && map[e.column]) || e));
     }
+    // @ts-ignore
+    else if (query.select().some(({ expr }) => expr.aggregate)) {
+      // if query is an ungrouped aggregate, add an explicit groupby to
+      // prevent improper consolidation with non-aggregate queries
+      q.$groupby('ALL');
+    }
 
     // key is just the transformed query as SQL
     return `${q}`;
@@ -244,22 +250,20 @@ async function processResults(group, cache) {
 
 /**
  * Project a consolidated result to a client result
- * @param {*} data Consolidated query result, as an Apache Arrow Table
- * @param {*} map Column name map as [source, target] pairs
+ * @param {import('@uwdata/flechette').Table} data
+ *  Consolidated query result, as an Arrow Table
+ * @param {[string, string][]} map Column name map as [source, target] pairs
  * @returns the projected Apache Arrow table
  */
 function projectResult(data, map) {
-  const cols = {};
-  for (const [name, as] of map) {
-    cols[as] = data.getChild(name);
-  }
-  return new data.constructor(cols);
+  return data.select(map.map(x => x[0]), map.map(x => x[1]));
 }
 
 /**
  * Filter a consolidated describe query result to a client result
- * @param {*} data Consolidated query result
- * @param {*} map Column name map as [source, target] pairs
+ * @param {import('@uwdata/flechette').Table} data
+ *  Consolidated query result, as an Arrow Table
+ * @param {[string, string][]} map Column name map as [source, target] pairs
  * @returns the filtered table data
  */
 function filterResult(data, map) {

package/src/QueryManager.js

@@ -1,13 +1,13 @@
 import { consolidator } from './QueryConsolidator.js';
 import { lruCache, voidCache } from './util/cache.js';
-import { priorityQueue } from './util/priority-queue.js';
+import { PriorityQueue } from './util/priority-queue.js';
 import { QueryResult } from './util/query-result.js';
 
 export const Priority = { High: 0, Normal: 1, Low: 2 };
 
 export class QueryManager {
   constructor() {
-    this.queue = priorityQueue(3);
+    this.queue = new PriorityQueue(3);
     this.db = null;
     this.clientCache = null;
     this._logger = null;
@@ -109,7 +109,13 @@ export class QueryManager {
   cancel(requests) {
     const set = new Set(requests);
     if (set.size) {
-      this.queue.remove(({ result }) => set.has(result));
+      this.queue.remove(({ result }) => {
+        if (set.has(result)) {
+          result.reject('Canceled');
+          return true;
+        }
+        return false;
+      });
     }
   }
 

package/src/Selection.js

@@ -10,6 +10,13 @@ export function isSelection(x) {
   return x instanceof Selection;
 }
 
+function create(options, include) {
+  return new Selection(
+    new SelectionResolver(options),
+    include ? [include].flat() : include
+  );
+}
+
 /**
  * Represents a dynamic set of query filter predicates.
  */
@@ -25,10 +32,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static intersect({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty }));
+  static intersect({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty }, include);
   }
 
   /**
@@ -41,10 +51,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static union({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty, union: true }));
+  static union({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty, union: true }, include);
   }
 
   /**
@@ -57,10 +70,13 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static single({ cross = false, empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross, empty, single: true }));
+  static single({ cross = false, empty = false, include = [] } = {}) {
+    return create({ cross, empty, single: true }, include);
   }
 
   /**
@@ -70,21 +86,34 @@ export class Selection extends Param {
    * @param {boolean} [options.empty=false] Boolean flag indicating if a lack
    *  of clauses should correspond to an empty selection with no records. This
    *  setting determines the default selection state.
+   * @param {Selection|Selection[]} [options.include] Upstream selections whose
+   *  clauses should be included as part of the new selection. Any clauses
+   *  published to upstream selections will be relayed to the new selection.
    * @returns {Selection} The new Selection instance.
    */
-  static crossfilter({ empty = false } = {}) {
-    return new Selection(new SelectionResolver({ cross: true, empty }));
+  static crossfilter({ empty = false, include = [] } = {}) {
+    return create({ cross: true, empty }, include);
   }
 
   /**
    * Create a new Selection instance.
-   * @param {SelectionResolver} resolver The selection resolution
+   * @param {SelectionResolver} [resolver] The selection resolution
    *  strategy to apply.
+   * @param {Selection[]} [include] Upstream selections whose clauses
+   * should be included as part of this selection. Any clauses published
+   * to these upstream selections will be relayed to this selection.
    */
-  constructor(resolver = new SelectionResolver()) {
+  constructor(resolver = new SelectionResolver(), include = []) {
     super([]);
     this._resolved = this._value;
     this._resolver = resolver;
+    /** @type {Set<Selection>} */
+    this._relay = new Set;
+    if (Array.isArray(include)) {
+      for (const sel of include) {
+        sel._relay.add(this);
+      }
+    }
   }
 
   /**
@@ -161,6 +190,7 @@ export class Selection extends Param {
    */
   activate(clause) {
     this.emit('activate', clause);
+    this._relay.forEach(sel => sel.activate(clause));
   }
 
   /**
@@ -173,6 +203,7 @@ export class Selection extends Param {
     // this ensures consistent clause state across unemitted event values
     this._resolved = this._resolver.resolve(this._resolved, clause, true);
     this._resolved.active = clause;
+    this._relay.forEach(sel => sel.update(clause));
     return super.update(this._resolved);
   }
 

package/src/connectors/rest.js

@@ -1,11 +1,11 @@
-import { tableFromIPC } from 'apache-arrow';
+import { decodeIPC } from '../util/decode-ipc.js';
 
 export function restConnector(uri = 'http://localhost:3000/') {
   return {
     /**
      * Query the DuckDB server.
      * @param {object} query
-     * @param {'exec' | 'arrow' | 'json'} [query.type] The query type: 'exec', 'arrow', or 'json'.
+     * @param {'exec' | 'arrow' | 'json' | 'create-bundle' | 'load-bundle'} [query.type] The query type.
      * @param {string} query.sql A SQL query string.
      * @returns the query result
      */
@@ -20,7 +20,7 @@ export function restConnector(uri = 'http://localhost:3000/') {
       });
 
       return query.type === 'exec' ? req
-        : query.type === 'arrow' ? tableFromIPC(req)
+        : query.type === 'arrow' ? decodeIPC(await (await req).arrayBuffer())
         : (await req).json();
     }
   };