duckdb 0.6.2-dev529.0 → 0.6.2-dev567.0

package/test/{affected.test.js → affected.test.ts}

@@ -1,22 +1,22 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
 
 describe('query properties', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:');
         db.run("CREATE TABLE foo (id INT, txt TEXT)", done);
     });
 
-/*
-    it('should return the correct lastID', function(done) {
+    it.skip('should return the correct lastID', function(done) {
         var stmt = db.prepare("INSERT INTO foo VALUES(?, ?)");
         var j = 1;
         for (var i = 0; i < 5000; i++) {
-            stmt.run(i, "demo", function(err) {
+            stmt.run(i, "demo", function(err: null | Error) {
                 if (err) throw err;
                 // Relies on SQLite's row numbering to be gapless and starting
                 // from 1.
+                // @ts-ignore
                 assert.equal(j++, this.lastID);
             });
         }
@@ -24,13 +24,11 @@ describe('query properties', function() {
     });
 
 
-    it('should return the correct changes count', function(done) {
-        db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err) {
+    it.skip('should return the correct changes count', function(done) {
+        db.run("UPDATE foo SET id = id + 1 WHERE id % 2 = 0", function(err: null | Error) {
             if (err) throw err;
            // FIXME assert.equal(2500, this.changes);
             done();
         });
     });
-    */
-
 });

package/test/{arrow.test.js → arrow.test.ts}

@@ -1,11 +1,12 @@
-var duckdb = require('..');
-var assert = require('assert');
-var fs = require('fs');
+import * as duckdb from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import {QueryResult} from "..";
 
 describe('arrow IPC API fails neatly when extension not loaded', function() {
     // Note: arrow IPC api requires the arrow extension to be loaded. The tests for this functionality reside in:
     //       https://github.com/duckdblabs/arrow
-    let db;
+    let db: duckdb.Database;
     let conn;
     before((done) => {
         db = new duckdb.Database(':memory:', {"allow_unsigned_extensions": "true"}, () => {
@@ -20,13 +21,13 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
         db.arrowIPCStream(query).then(
             () => Promise.reject(new Error('Expected method to reject.')),
             err => {
-                assert(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
             }
         );
 
-        db.arrowIPCAll(`SELECT * FROM ipc_table`, function (err, result) {
+        db.arrowIPCAll(`SELECT * FROM ipc_table`, function (err: null | Error, result: QueryResult) {
             if (err) {
-                assert(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
+                assert.ok(err.message.includes("Catalog Error: Function with name to_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"))
             } else {
                 assert.fail("Expected error");
             }
@@ -36,16 +37,16 @@ describe('arrow IPC API fails neatly when extension not loaded', function() {
     });
 
     it('register buffer should be disabled currently', function(done) {
-        db.register_buffer("test", [new Uint8Array(new ArrayBuffer(10))], true, (err) => {
-            assert(err)
-            assert(err.includes("Function with name scan_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"));
+        db.register_buffer("test", [new Uint8Array(new ArrayBuffer(10))], true, (err: null | Error) => {
+            assert.ok(err)
+            assert.ok(err.toString().includes("Function with name scan_arrow_ipc is not on the catalog, but it exists in the arrow extension. To Install and Load the extension, run: INSTALL arrow; LOAD arrow;"));
             done()
         });
     });
 
     it('unregister will silently do nothing', function(done) {
         db.unregister_buffer("test", (err) => {
-            assert(!err)
+            assert.ok(!err)
             done()
         });
     });

package/test/{data_type_support.test.js → data_type_support.test.ts}

@@ -1,8 +1,9 @@
-var sqlite3 = require("..");
-var assert = require("assert");
+import * as sqlite3 from "..";
+import * as assert from "assert";
+import {RowData, TableData} from "..";
 
 describe("data type support", function () {
-  let db;
+  let db: sqlite3.Database;
   before(function (done) {
     db = new sqlite3.Database(":memory:", done);
   });
@@ -14,9 +15,9 @@ describe("data type support", function () {
     values.forEach((bool) => {
       stmt.run(bool);
     });
-    db.prepare("SELECT i from boolean_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.every((v, i) => v.i === values[i]));
+    db.prepare("SELECT i from boolean_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.ok(res.every((v, i) => v.i === values[i]));
       done();
     });
   });
@@ -26,9 +27,9 @@ describe("data type support", function () {
     const stmt = db.prepare("INSERT INTO integer_table VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
 
     // Numerical limits
-    signedMinValue = (bitWidth) => Math.max(-(2**(bitWidth-1)-1)-1, Number.MIN_SAFE_INTEGER);
-    signedMaxValue = (bitWidth) => Math.min(2**(bitWidth-1)-1, Number.MAX_SAFE_INTEGER);
-    unsignedMaxValue = (bitWidth) => Math.min(2**(bitWidth)-1, Number.MAX_SAFE_INTEGER);
+    let signedMinValue = (bitWidth: number) => Math.max(-(2**(bitWidth-1)-1)-1, Number.MIN_SAFE_INTEGER);
+    let signedMaxValue = (bitWidth: number) => Math.min(2**(bitWidth-1)-1, Number.MAX_SAFE_INTEGER);
+    let unsignedMaxValue = (bitWidth: number) => Math.min(2**(bitWidth)-1, Number.MAX_SAFE_INTEGER);
     let minValues = [signedMinValue(8), signedMinValue(16), signedMinValue(32), signedMinValue(64), 0, 0, 0, 0];
     let maxValues = [signedMinValue(8), signedMinValue(16), signedMinValue(32), signedMinValue(64), unsignedMaxValue(8), unsignedMaxValue(16), unsignedMaxValue(32), unsignedMaxValue(64)];
 
@@ -36,11 +37,11 @@ describe("data type support", function () {
     stmt.run(...minValues);
     stmt.run(...maxValues);
 
-    db.prepare("SELECT * from integer_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.length === 2);
-      assert(Object.entries(res[0]).length === 8);
-      assert(Object.entries(res[1]).length === 8);
+    db.prepare("SELECT * from integer_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.equal(res.length, 2);
+      assert.equal(Object.entries(res[0]).length, 8);
+      assert.equal(Object.entries(res[1]).length, 8);
       assert.deepEqual(Object.entries(res[0]).map(v => v[1]), minValues);
       assert.deepEqual(Object.entries(res[1]).map(v => v[1]), maxValues);
       done();
@@ -54,8 +55,8 @@ describe("data type support", function () {
     INTERVAL 5 DAY as days,
     INTERVAL 4 MONTH as months,
     INTERVAL 4 MONTH + INTERVAL 5 DAY + INTERVAL 1 MINUTE as combined;`
-    ).each((err, row) => {
-      assert(err === null);
+    ).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.minutes, {
         months: 0,
         days: 0,
@@ -74,7 +75,7 @@ describe("data type support", function () {
 
   it("supports STRUCT values", function (done) {
     db.prepare(`SELECT {'x': 1, 'y': 2, 'z': {'a': 'b'}} as struct`).each(
-      (err, row) => {
+      (err: null | Error, row: RowData) => {
         assert.deepEqual(row.struct, { x: 1, y: 2, z: { a: "b" } });
         done();
       }
@@ -86,8 +87,8 @@ describe("data type support", function () {
     db.run("INSERT INTO struct_table VALUES ({'a': 'hello', 'b': true})");
     db.run("INSERT INTO struct_table VALUES ({'a': 'goodbye', 'b': false})");
     db.run("INSERT INTO struct_table VALUES ({'a': 'aloha', 'b': NULL})");
-    db.prepare("SELECT s from struct_table;").all((err, res) => {
-      assert(err === null);
+    db.prepare("SELECT s from struct_table;").all((err: null | Error, res: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(res, [
         { s: { a: "hello", b: true } },
         { s: { a: "goodbye", b: false } },
@@ -106,8 +107,8 @@ describe("data type support", function () {
       {'a': 43, 'b': NULL}
    ] l UNION ALL SELECT NULL`
     );
-    db.prepare("SELECT l from recursive_struct").all((err, res) => {
-      assert(err === null);
+    db.prepare("SELECT l from recursive_struct").all((err: null | Error, res: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(res, [
         {
           l: [
@@ -135,32 +136,32 @@ describe("data type support", function () {
   });
 
   it("supports LIST values", function (done) {
-    db.prepare(`SELECT ['duck', 'duck', 'goose'] as list`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT ['duck', 'duck', 'goose'] as list`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.list, ["duck", "duck", "goose"]);
       done();
     });
   });
 
   it("supports LIST with NULL values", function (done) {
-    db.prepare(`SELECT ['duck', 'duck', NULL] as list`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT ['duck', 'duck', NULL] as list`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.list, ["duck", "duck", null]);
       done();
     });
   });
 
   it("supports DATE values", function (done) {
-    db.prepare(`SELECT '2021-01-01'::DATE as dt;`).each((err, row) => {
-      assert(err === null);
+    db.prepare(`SELECT '2021-01-01'::DATE as dt;`).each((err: null | Error, row: RowData) => {
+      assert.equal(err, null);
       assert.deepEqual(row.dt, new Date(Date.UTC(2021, 0, 1)));
       done();
     });
   });
   it("supports TIMESTAMP values", function (done) {
     db.prepare(`SELECT '2021-01-01T00:00:00'::TIMESTAMP as ts;`).each(
-      (err, row) => {
-        assert(err === null);
+      (err: null | Error, row: RowData) => {
+        assert.equal(err, null);
         assert.deepEqual(row.ts, new Date(Date.UTC(2021, 0, 1)));
         done();
       }
@@ -168,8 +169,8 @@ describe("data type support", function () {
   });
   it("supports TIMESTAMP WITH TIME ZONE values", function (done) {
     db.prepare(`SELECT '2021-01-01T00:00:00Z'::TIMESTAMPTZ as tstz;`).each(
-      (err, row) => {
-        assert(err === null);
+      (err: null | Error, row: RowData) => {
+        assert.equal(err, null);
         assert.deepEqual(row.tstz, new Date(Date.UTC(2021, 0, 1)));
         done();
       }
@@ -182,14 +183,14 @@ describe("data type support", function () {
     values.forEach((d) => {
       stmt.run(d);
     });
-    db.prepare("SELECT d from decimal_table;").all((err, res) => {
-      assert(err === null);
-      assert(res.every((v, i) => v.d === values[i]));
+    db.prepare("SELECT d from decimal_table;").all((err: null | Error, res: TableData) => {
+      assert.equal(err, null);
+      assert.ok(res.every((v, i) => v.d === values[i]));
       done();
     });
   });
   it("converts unsupported data types to strings", function(done) {
-      db.all("SELECT CAST('11:10:10' AS TIME) as time", function(err, rows) {
+      db.all("SELECT CAST('11:10:10' AS TIME) as time", function(err: null | Error, rows: TableData) {
           assert.equal(rows[0].time, '11:10:10');
           done();
       });

package/test/{database_fail.test.js → database_fail.test.ts}

@@ -1,24 +1,27 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {DuckDbError, RowData} from "..";
 
 describe('error handling', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);
     });
 
     it('throw when calling Database() without new', function() {
         assert.throws(function() {
+            // @ts-ignore
             sqlite3.Database(':memory:');
         }, (/Class constructors cannot be invoked without 'new'/));
 
         assert.throws(function() {
+            // @ts-ignore
             sqlite3.Statement();
         }, (/Class constructors cannot be invoked without 'new'/));
     });
 
     it('should error when calling Database#each on a missing table', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -30,7 +33,7 @@ describe('error handling', function() {
     });
 
     it('Database#all prepare fail', function(done) {
-        db.all('SELECT id, txt FROM foo', function(err, row) {
+        db.all('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -42,7 +45,7 @@ describe('error handling', function() {
     });
 
     it('Database#run prepare fail', function(done) {
-        db.run('SELECT id, txt FROM foo', function(err, row) {
+        db.run('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: void) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -53,11 +56,10 @@ describe('error handling', function() {
         });
     });
 
-/*
-    it('Database#each prepare fail', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+    it.skip('Database#each prepare fail', function(done) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             assert.ok(false, "this should not be called");
-        }, function(err, num) {
+        }, function(err: null | DuckDbError, num: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -67,9 +69,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#each prepare fail without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo', function(err, row) {
+        db.each('SELECT id, txt FROM foo', function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -79,9 +81,9 @@ describe('error handling', function() {
             }
         });
     });
-/*
-    it('Database#get prepare fail with param binding', function(done) {
-        db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+
+    it.skip('Database#get prepare fail with param binding', function(done) {
+        db.get('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -91,9 +93,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#all prepare fail with param binding', function(done) {
-        db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.all('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -105,7 +107,7 @@ describe('error handling', function() {
     });
 
     it('Database#run prepare fail with param binding', function(done) {
-        db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.run('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: void) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -116,11 +118,10 @@ describe('error handling', function() {
         });
     });
 
-/*
-    it('Database#each prepare fail with param binding', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+    it.skip('Database#each prepare fail with param binding', function(done) {
+        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             assert.ok(false, "this should not be called");
-        }, function(err, num) {
+        }, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);
@@ -130,9 +131,9 @@ describe('error handling', function() {
             }
         });
     });
-*/
+
     it('Database#each prepare fail with param binding without completion handler', function(done) {
-        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE id = ?', 1, function(err: null | DuckDbError, row: RowData) {
             if (err) {
                 assert.equal(err.message.includes('does not exist'), 1);
                 assert.equal(err.errno, sqlite3.ERROR);

package/test/{each.test.js → each.test.ts}

@@ -1,8 +1,9 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {RowData} from "..";
 
 describe('each', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database('test/support/big.db', done);
     });
@@ -12,7 +13,7 @@ describe('each', function() {
         var retrieved = 0;
         
 
-        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err: null | Error, row: RowData) {
             if (err) throw err;
             retrieved++;
 
@@ -22,18 +23,18 @@ describe('each', function() {
             }
         });
     });
-/*
-    it('Statement#each with complete callback', function(done) {
+
+    it.skip('Statement#each with complete callback', function(done) {
         var total = 10000;
         var retrieved = 0;
 
-        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err, row) {
+        db.each('SELECT id, txt FROM foo WHERE ROWID < ?', total, function(err: null | Error, row: RowData) {
             if (err) throw err;
             retrieved++;
-        }, function(err, num) {
+        }, function(err: null | Error, num: RowData) {
             assert.equal(retrieved, num);
             assert.equal(retrieved, total, "Only retrieved " + retrieved + " out of " + total + " rows.");
             done();
         });
-    });*/
+    });
 });

package/test/{exec.test.js → exec.test.ts}

@@ -1,23 +1,24 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import {TableData} from "..";
 
 describe('exec', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);
     });
 
     it('Database#exec', function(done) {
         var sql = fs.readFileSync('test/support/script.sql', 'utf8');
-        db.exec(sql, function(err) {
+        db.exec(sql, function(err: null | Error) {
             if (err) throw err;
             done();
         });
     });
 
     it('retrieve database structure', function(done) {
-        db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err, rows) {
+        db.all("SELECT type, name FROM sqlite_master ORDER BY type, name", function(err: null | Error, rows: TableData) {
             if (err) throw err;
             assert.deepEqual(rows, [
                // { type: 'index', name: 'grid_key_lookup' },

package/test/{extension.test.js → extension.test.ts}

@@ -1,27 +1,29 @@
-var duckdb = require('..');
-var fs = require('fs');
-var assert = require('assert');
-var path = require('path');
+import * as duckdb from '..';
+import {Database, TableData} from '..';
+import * as fs from 'fs';
+import * as assert from 'assert';
+import * as path from 'path';
+import {Done} from "mocha";
 
 const extension_base_path = "../../../build/release/extension";
 
 // Look for extensions that we can load and test
-let extension_paths = [];
+let extension_paths: string[] = [];
 const extension_full_path = path.resolve(__dirname, extension_base_path);
 if (fs.existsSync(extension_full_path)) {
-    extension_paths = extension_paths.concat(fs.readdirSync(extension_full_path).map(function (file) {
-        if (!fs.statSync(extension_full_path+'/'+file).isDirectory())
+    extension_paths = fs.readdirSync(extension_full_path).map(function (file) {
+        if (!fs.statSync(extension_full_path + '/' + file).isDirectory())
             return undefined;
-        const potential_extension_path = extension_full_path+`/${file}/${file}.duckdb_extension`;
+        const potential_extension_path = extension_full_path + `/${file}/${file}.duckdb_extension`;
         if (fs.existsSync(potential_extension_path)) {
             return potential_extension_path;
         }
-    }).filter(a=>a));
+    }).filter(a => a) as string[];
 }
 
 // Note: test will pass on http request failing due to connection issues.
-const test_httpfs = async function (db, done) {
-    db.all("SELECT id, first_name, last_name FROM PARQUET_SCAN('https://raw.githubusercontent.com/cwida/duckdb/master/data/parquet-testing/userdata1.parquet') LIMIT 3;", function(err, rows) {
+const test_httpfs = async function (db: duckdb.Database, done: Done) {
+    db.all("SELECT id, first_name, last_name FROM PARQUET_SCAN('https://raw.githubusercontent.com/cwida/duckdb/master/data/parquet-testing/userdata1.parquet') LIMIT 3;", function(err: null | Error, rows: TableData) {
         if (err) {
             if (err.message.startsWith("Unable to connect to URL")) {
                 console.warn("Warning: HTTP request failed in extension.test.js");
@@ -40,8 +42,8 @@ const test_httpfs = async function (db, done) {
     });
 };
 
-const test_tpch = async function (db, done) {
-    db.all("CALL DBGEN(sf=0.01);", function(err) {
+const test_tpch = async function (db: Database, done:Done) {
+    db.all("CALL DBGEN(sf=0.01);", function(err: null | Error) {
         if (err) {
             throw err;
         }
@@ -49,7 +51,7 @@ const test_tpch = async function (db, done) {
     });
 };
 
-const test_extension = function(extension_name, db, done) {
+const test_extension = function(extension_name: string, db: duckdb.Database, done: Done) {
     switch(extension_name) {
         case 'httpfs.duckdb_extension':
             test_httpfs(db, done);
@@ -64,22 +66,21 @@ const test_extension = function(extension_name, db, done) {
 };
 
 describe('Extension loading', function() {
-    var db;
+    var db: Database;
 
     before(function(done) {
         db = new duckdb.Database(':memory:', {"allow_unsigned_extensions":"true"}, done);
     });
 
-    for (ext of extension_paths) {
-        const extension_path = ext;
-        const extension_name = ext.replace(/^.*[\\\/]/, '');
+    for (let extension_path of extension_paths) {
+        const extension_name = extension_path.replace(/^.*[\\\/]/, '');
 
         if (extension_name.startsWith('parquet')) { // Parquet is built-in in the Node client, so skip
             continue;
         }
 
         it(extension_name, function(done) {
-            db.run(`LOAD '${extension_path}';`, function(err) {
+            db.run(`LOAD '${extension_path}';`, function(err: null | Error) {
                 if (err) {
                     throw err;
                 }

package/test/{interrupt.test.js → interrupt.test.ts}

@@ -1,13 +1,13 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import {DuckDbError} from "..";
 
 // FIXME each is not streaming yet
-return
 
-describe('interrupt', function() {
+describe.skip('interrupt', function() {
     it('should interrupt queries', function(done) {
         var interrupted = false;
-        var saved = null;
+        var saved: DuckDbError | null = null;
 
         var db = new sqlite3.Database(':memory:', function() {
             db.serialize();
@@ -17,7 +17,7 @@ describe('interrupt', function() {
                 setup += 'insert into t values (' + i + ');';
             }
 
-            db.exec(setup, function(err) {
+            db.exec(setup, function(err: null | Error) {
                 if (err) {
                     return done(err);
                 }
@@ -25,7 +25,7 @@ describe('interrupt', function() {
                 var query = 'select last.n ' +
                     'from t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t,t as last';
 
-                db.each(query, function(err) {
+                db.each(query, function(err: null | DuckDbError) {
                     if (err) {
                         saved = err;
                     } else if (!interrupted) {