duckdb 0.6.2-dev6.0 → 0.6.2-dev604.0

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) {

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

@@ -2,46 +2,43 @@
  * Intended to be similar to stubtest for python
  */
 
-var duckdb = require("..");
-var jsdoc = require("jsdoc3-parser");
+import * as duckdb from "..";
+// @ts-ignore
+import jsdoc from "jsdoc3-parser";
 const { expect } = require('chai');
 const { promisify } = require('util');
 
-function lastDot(string) {
+function lastDot(string: string) {
   if (string.endsWith(')')) {
-    string = string.substr(0, string.length - 1);
+    string = string.substring(0, string.length - 1);
   }
   const array = string.split('.');
   return array[array.length - 1];
 }
 
-/**
- * @typedef {Object} Node
- * @property {string} name
- * @property {string} memberof
- * @property {string} longname
- * @property {string} scope
- */
-
+export interface Node {
+  undocumented: boolean;
+  name: string;
+  memberof: string;
+  longname: string;
+  scope: string;
+}
 describe("JSDoc contains all methods", () => {
-  /**
-   * @type {Node[]}
-   */
-  let docs;
+  let docs: Node[];
   before(async () => {
     docs = await promisify(jsdoc)(require.resolve("../lib/duckdb"));
   })
 
-  function checkDocs(obj, scope) {
+  function checkDocs(obj: object, scope: string) {
     const symbols = Object.getOwnPropertySymbols(obj).map(i => lastDot(i.toString()));
     const expected = Object
       .getOwnPropertyNames(obj)
       .concat(symbols)
       .sort()
-      .filter(name => name !== 'constructor');
+      .filter(name => name !== 'constructor' && name !== 'default');
 
     const actual = docs
-      .filter((node) => node.memberof === scope && !node.undocumented)
+      .filter((node) => node.memberof === scope && !node.undocumented && node.name !== 'sql')  // `sql` is a field, so won't show up in the prototype
       .map((node) => lastDot(node.name))
       .sort();
 
@@ -50,7 +47,9 @@ describe("JSDoc contains all methods", () => {
 
   for (const clazz of ['Database', 'QueryResult', 'Connection', 'Statement']) {
     it(clazz, () => {
-      checkDocs(duckdb[clazz].prototype, `module:duckdb~${clazz}`);
+      // @ts-ignore
+      let clazzObj = duckdb[clazz];
+      checkDocs(clazzObj.prototype, `module:duckdb~${clazz}`);
     });
   }
 

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

@@ -1,11 +1,9 @@
-var sqlite3 = require('..');
-var assert = require('assert');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
 
 // TODO
-return
-
-describe('named columns', function() {
-    var db;
+describe.skip('named columns', function() {
+    var db: sqlite3.Database;
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);
     });

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

@@ -1,10 +1,9 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as helper from './support/helper';
 
 describe('null error', function() {
     var filename = 'test/tmp/test_sqlite_ok_error.db';
-    var db;
+    var db: sqlite3.Database;
 
     before(function(done) {
         helper.ensureExists('test/tmp');
@@ -17,7 +16,7 @@ describe('null error', function() {
     });
 
     it('should insert rows with lots of null values', function(done) {
-        var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err) {
+        var stmt = db.prepare('INSERT INTO febp_data VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)', function(err: null | Error) {
             if (err) throw err;
 
             for (var i = 0; i < 100; i++) {
@@ -32,7 +31,7 @@ describe('null error', function() {
     });
 
     it('should have created the database', function() {
-        assert.fileExists(filename);
+        helper.fileExists(filename);
     });
 
     after(function() {

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

@@ -1,7 +1,7 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var fs = require('fs');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as assert from 'assert';
+import * as fs from 'fs';
+import * as helper from './support/helper';
 
 describe('open/close', function() {
     before(function() {
@@ -13,7 +13,7 @@ describe('open/close', function() {
             helper.deleteFile('test/tmp/test_create.db');
         });
 
-        var db;
+        var db: sqlite3.Database;
         it('should open the database', function(done) {
             db = new sqlite3.Database('test/tmp/test_create.db', done);
         });
@@ -23,7 +23,7 @@ describe('open/close', function() {
         });
 
         it('should have created the file', function() {
-            assert.fileExists('test/tmp/test_create.db');
+            helper.fileExists('test/tmp/test_create.db');
         });
 
         after(function() {
@@ -123,7 +123,7 @@ describe('open/close', function() {
         });
 
         it('should not have created the file', function() {
-            assert.fileDoesNotExist('test/tmp/test_readonly.db');
+            helper.fileDoesNotExist('test/tmp/test_readonly.db');
         });
 
         after(function() {
@@ -132,7 +132,7 @@ describe('open/close', function() {
     });
 
     describe('open and close memory database queuing', function() {
-        var db;
+        var db: sqlite3.Database;
         it('should open the database', function(done) {
             db = new sqlite3.Database(':memory:', done);
         });
@@ -155,7 +155,7 @@ describe('open/close', function() {
         var completedSecond = false;
         var closed = false;
 
-        var db;
+        var db: sqlite3.Database;
         before(function(done) {
             db = new sqlite3.Database(':memory:', done);
         });
@@ -164,7 +164,7 @@ describe('open/close', function() {
             db.run("CREATE TABLE foo (id INT, num INT)", done);
         });
 
-        var stmt;
+        var stmt: sqlite3.Statement;
         it('should prepare/run a statement', function(done) {
             stmt = db.prepare('INSERT INTO foo VALUES (?, ?)');
             stmt.run(1, 2, done);

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

@@ -1,22 +1,21 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
+import * as helper from './support/helper';
 
 describe('parallel', function() {
-    var db;
+    var db: sqlite3.Database;
     before(function(done) {
         helper.deleteFile('test/tmp/test_parallel_inserts.db');
         helper.ensureExists('test/tmp');
         db = new sqlite3.Database('test/tmp/test_parallel_inserts.db', done);
     });
 
-    var columns = [];
+    var columns: string[] = [];
     for (var i = 0; i < 128; i++) {
         columns.push('id' + i + " INTEGER");
     }
 
     it('should create the table', function(done) {
-        db.run("CREATE TABLE foo (" + columns + ")", function(err) {
+        db.run("CREATE TABLE foo (" + columns + ")", function(err: null | Error) {
             done();
         });
     });
@@ -37,7 +36,7 @@ describe('parallel', function() {
     });
 
     it('should verify that the database exists', function() {
-        assert.fileExists('test/tmp/test_parallel_inserts.db');
+        helper.fileExists('test/tmp/test_parallel_inserts.db');
     });
 
     after(function() {

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

@@ -1,9 +1,7 @@
-var sqlite3 = require('..');
-var assert = require('assert');
-var helper = require('./support/helper');
+import * as sqlite3 from '..';
 
 describe('can query parquet', function() {
-    var db;
+    var db: sqlite3.Database;
 
     before(function(done) {
         db = new sqlite3.Database(':memory:', done);

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

@@ -1,8 +1,9 @@
-var sqlite3 = require("..");
-var assert = require("assert");
+import * as sqlite3 from "..";
+import * as assert from "assert";
+import {DuckDbError, TableData} from "..";
 
 describe("pathname search support", function () {
-  let db;
+  let db: sqlite3.Database;
   describe("without search paths", () => {
     before((done) => {
       db = new sqlite3.Database(":memory:", done);
@@ -10,19 +11,20 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("don't not support a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err.code === "DUCKDB_NODEJS_ERROR");
-        assert(err.errno === -1);
-        assert(result == null);
+      db.prepare('select * from "prepare.csv"').all((err: null | DuckDbError, result: TableData) => {
+        assert.ok(err);
+        assert.equal(err.code, "DUCKDB_NODEJS_ERROR");
+        assert.equal(err.errno, -1);
+        assert.equal(result, null);
         done();
       });
     });
@@ -37,18 +39,18 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("supports a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err === null);
-        assert(result.length === 5000);
+      db.prepare('select * from "prepare.csv"').all((err: null | Error, result: TableData) => {
+        assert.equal(err, null);
+        assert.equal(result.length, 5000);
         done();
       });
     });
@@ -63,18 +65,18 @@ describe("pathname search support", function () {
 
     it("supports a full path", function (done) {
       db.prepare('select * from "test/support/prepare.csv"').all(
-        (err, result) => {
-          assert(err === null);
-          assert(result.length === 5000);
+        (err: null | Error, result: TableData) => {
+          assert.equal(err, null);
+          assert.equal(result.length, 5000);
           done();
         }
       );
     });
 
     it("supports a partial path", function (done) {
-      db.prepare('select * from "prepare.csv"').all((err, result) => {
-        assert(err === null);
-        assert(result.length === 5000);
+      db.prepare('select * from "prepare.csv"').all((err: null | Error, result: TableData) => {
+        assert.equal(err, null);
+        assert.equal(result.length, 5000);
         done();
       });
     });