@malloydata/db-duckdb 0.0.331 → 0.0.333

package/dist/duckdb_connection.d.ts

@@ -1,6 +1,6 @@
 import { DuckDBCommon } from './duckdb_common';
-import type { Connection, TableData } from 'duckdb';
-import { Database } from 'duckdb';
+import { DuckDBInstance } from '@duckdb/node-api';
+import type { DuckDBConnection as DuckDBNodeConnection } from '@duckdb/node-api';
 import type { ConnectionConfig, QueryDataRow, QueryOptionsReader, RunSQLOptions } from '@malloydata/malloy';
 export interface DuckDBConnectionOptions extends ConnectionConfig {
     additionalExtensions?: string[];
@@ -10,8 +10,8 @@ export interface DuckDBConnectionOptions extends ConnectionConfig {
     readOnly?: boolean;
 }
 interface ActiveDB {
-    database: Database;
-    connections: Connection[];
+    instance: DuckDBInstance;
+    connections: DuckDBNodeConnection[];
 }
 export declare class DuckDBConnection extends DuckDBCommon {
     readonly name: string;
@@ -20,7 +20,7 @@ export declare class DuckDBConnection extends DuckDBCommon {
     private workingDirectory;
     private readOnly;
     connecting: Promise<void>;
-    protected connection: Connection | null;
+    protected connection: DuckDBNodeConnection | null;
     protected setupError: Error | undefined;
     protected isSetup: Promise<void> | undefined;
     static activeDBs: Record<string, ActiveDB>;
@@ -30,7 +30,7 @@ export declare class DuckDBConnection extends DuckDBCommon {
     loadExtension(ext: string): Promise<void>;
     protected setup(): Promise<void>;
     protected runDuckDBQuery(sql: string): Promise<{
-        rows: TableData;
+        rows: QueryDataRow[];
         totalRows: number;
     }>;
     runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryDataRow>;

package/dist/duckdb_connection.js

@@ -28,7 +28,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.DuckDBConnection = void 0;
 const crypto_1 = __importDefault(require("crypto"));
 const duckdb_common_1 = require("./duckdb_common");
-const duckdb_1 = require("duckdb");
+const node_api_1 = require("@duckdb/node-api");
 const package_json_1 = __importDefault(require("@malloydata/malloy/package.json"));
 class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
     constructor(arg, arg2, workingDirectory, queryOptions) {
@@ -80,24 +80,22 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         this.connecting = this.init();
     }
     async init() {
-        return new Promise(resolve => {
+        try {
             if (this.databasePath in DuckDBConnection.activeDBs) {
                 const activeDB = DuckDBConnection.activeDBs[this.databasePath];
-                this.connection = activeDB.database.connect();
+                this.connection = await activeDB.instance.connect();
                 activeDB.connections.push(this.connection);
-                resolve();
             }
             else {
                 const config = {
-                    'custom_user_agent': `Malloy/${package_json_1.default.version}`,
+                    custom_user_agent: `Malloy/${package_json_1.default.version}`,
                 };
                 if (this.isMotherDuck) {
                     if (!this.motherDuckToken &&
                         !process.env['motherduck_token'] &&
                         !process.env['MOTHERDUCK_TOKEN']) {
                         this.setupError = new Error('Please set your MotherDuck Token');
-                        // Resolve instead of error because errors cannot be caught.
-                        return resolve();
+                        return;
                     }
                     if (this.motherDuckToken) {
                         config['motherduck_token'] = this.motherDuckToken;
@@ -106,23 +104,18 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
                 if (this.readOnly) {
                     config['access_mode'] = 'READ_ONLY';
                 }
-                const database = new duckdb_1.Database(this.databasePath, config, err => {
-                    if (err) {
-                        this.setupError = err;
-                    }
-                    else {
-                        this.connection = database.connect();
-                        const activeDB = {
-                            database,
-                            connections: [],
-                        };
-                        DuckDBConnection.activeDBs[this.databasePath] = activeDB;
-                        activeDB.connections.push(this.connection);
-                    }
-                    resolve();
-                });
+                const instance = await node_api_1.DuckDBInstance.create(this.databasePath, config);
+                this.connection = await instance.connect();
+                const activeDB = {
+                    instance,
+                    connections: [this.connection],
+                };
+                DuckDBConnection.activeDBs[this.databasePath] = activeDB;
             }
-        });
+        }
+        catch (err) {
+            this.setupError = err instanceof Error ? err : new Error(String(err));
+        }
     }
     async loadExtension(ext) {
         try {
@@ -172,25 +165,16 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         await this.isSetup;
     }
     async runDuckDBQuery(sql) {
-        return new Promise((resolve, reject) => {
-            if (this.connection) {
-                this.connection.all(sql, (err, rows) => {
-                    if (err) {
-                        reject(err);
-                    }
-                    else {
-                        // rows = processBigInts(rows);
-                        resolve({
-                            rows,
-                            totalRows: rows.length,
-                        });
-                    }
-                });
-            }
-            else {
-                reject(new Error('Connection not open'));
-            }
-        });
+        if (!this.connection) {
+            throw new Error('Connection not open');
+        }
+        const result = await this.connection.run(sql);
+        // getRowObjectsJson() converts nested types (LIST, STRUCT) to JS arrays/objects
+        const rows = (await result.getRowObjectsJson());
+        return {
+            rows,
+            totalRows: rows.length,
+        };
     }
     async *runSQLStream(sql, { rowLimit, abortSignal } = {}) {
         const defaultOptions = this.readQueryOptions();
@@ -204,14 +188,17 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
             await this.runDuckDBQuery(statements[0]);
             statements.shift();
         }
+        const result = await this.connection.stream(statements[0]);
         let index = 0;
-        for await (const row of this.connection.stream(statements[0])) {
-            if ((rowLimit !== undefined && index >= rowLimit) ||
-                (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
-                break;
+        for await (const chunk of result.yieldRowObjectJson()) {
+            for (const row of chunk) {
+                if ((rowLimit !== undefined && index >= rowLimit) ||
+                    (abortSignal === null || abortSignal === void 0 ? void 0 : abortSignal.aborted)) {
+                    return;
+                }
+                index++;
+                yield row;
             }
-            index++;
-            yield row;
         }
     }
     async createHash(sqlCommand) {
@@ -222,7 +209,7 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         if (activeDB) {
             activeDB.connections = activeDB.connections.filter(connection => connection !== this.connection);
             if (activeDB.connections.length === 0) {
-                activeDB.database.close();
+                activeDB.instance.closeSync();
                 delete DuckDBConnection.activeDBs[this.databasePath];
             }
         }

package/dist/duckdb_wasm_connection.js

@@ -292,6 +292,7 @@ class DuckDBWASMConnection extends duckdb_common_1.DuckDBCommon {
             if (this.databasePath) {
                 await this._database.open({
                     path: this.databasePath,
+                    accessMode: duckdb.DuckDBAccessMode.AUTOMATIC,
                 });
             }
             URL.revokeObjectURL(workerUrl);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.331",
+  "version": "0.0.333",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -44,11 +44,11 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@duckdb/duckdb-wasm": "1.29.1-dev132.0",
-    "@malloydata/malloy": "0.0.331",
+    "@duckdb/duckdb-wasm": "1.33.1-dev13.0",
+    "@duckdb/node-api": "1.4.3-r.1",
+    "@malloydata/malloy": "0.0.333",
     "@motherduck/wasm-client": "^0.6.6",
     "apache-arrow": "^17.0.0",
-    "duckdb": "1.3.4",
     "web-worker": "^1.3.0"
   }
 }