feat: implement unregisterFile method

Add queryToJSON method to DuckDB ConnectionHelper class
Bump Versions

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

package-lock.json

@@ -87,31 +87,31 @@
   "devDependencies": {
     "@eslint/js": "9.39.2",
     "@types/emscripten": "1.41.5",
-    "@types/node": "24.10.4",
+    "@types/node": "24.10.7",
     "@types/yargs": "17.0.35",
-    "@typescript-eslint/parser": "8.49.0",
-    "@vitest/browser": "4.0.15",
-    "@vitest/browser-playwright": "4.0.15",
-    "@vitest/coverage-istanbul": "4.0.15",
-    "@vitest/coverage-v8": "4.0.15",
+    "@typescript-eslint/parser": "8.53.0",
+    "@vitest/browser": "4.0.17",
+    "@vitest/browser-playwright": "4.0.17",
+    "@vitest/coverage-istanbul": "4.0.17",
+    "@vitest/coverage-v8": "4.0.17",
     "assemblyscript": "0.28.9",
     "chokidar-cli": "3.0.0",
     "eslint": "9.39.2",
     "globals": "16.5.0",
-    "happy-dom": "20.0.11",
+    "happy-dom": "20.1.0",
     "lerna": "9.0.3",
     "npm-run-all": "4.1.5",
     "playwright": "1.57.0",
     "release-please": "17.1.3",
     "rimraf": "6.1.2",
     "run-script-os": "1.1.6",
     "tslib": "2.8.1",
-    "typedoc": "0.28.15",
+    "typedoc": "0.28.16",
     "typedoc-plugin-markdown": "4.9.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.49.0",
+    "typescript-eslint": "8.53.0",
     "vitepress": "1.6.4",
-    "vitest": "4.0.15"
+    "vitest": "4.0.17"
   },
   "c8": {
     "exclude-after-remap": []

package.json

@@ -39,7 +39,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@hpcc-js/esbuild-plugins": "1.7.0",
+    "@hpcc-js/esbuild-plugins": "1.8.0",
     "@hpcc-js/wasm-util": "1.0.0"
   },
   "keywords": [

packages/base91/package.json

@@ -133,6 +133,24 @@ const progress = connection.getQueryProgress();
 console.log(`Query is ${progress * 100}% complete`);
 ```
 
+##### `queryToJSON(sql: string): string`
+Executes a SQL query and returns the result directly as a JSON string. This is a convenience method that combines `query()` and `toJSON()` into a single call.
+
+```typescript
+const json = connection.queryToJSON("SELECT * FROM users WHERE age > 18");
+// Returns: '[{"id":1,"name":"Alice","age":30},{"id":2,"name":"Bob","age":25}]'
+
+const users = JSON.parse(json);
+console.log(users[0].name); // "Alice"
+```
+
+**Features:**
+- No need to manually delete the result (automatic cleanup)
+- Returns an empty array `[]` for queries with no results
+- Handles all data types including NULL, numbers, strings, and booleans
+- Proper JSON escaping for special characters
+- NaN and Infinity are converted to `null`
+
 #### Transaction Management
 
 ##### `beginTransaction(): void`
@@ -549,6 +567,34 @@ users.forEach(user => {
 result.delete();
 ```
 
+### Direct JSON Query (queryToJSON)
+
+```typescript
+const connection = duckdb.connect();
+
+// Convenience method: execute query and get JSON in one call
+const json = connection.queryToJSON("SELECT * FROM users ORDER BY age");
+
+// No need to delete result - it's automatic!
+const users = JSON.parse(json);
+users.forEach(user => {
+    console.log(`${user.name} is ${user.age} years old`);
+});
+
+// Use with aggregations
+const stats = connection.queryToJSON(`
+    SELECT 
+        department,
+        COUNT(*) as count,
+        AVG(salary) as avg_salary
+    FROM employees
+    GROUP BY department
+`);
+console.log(stats);
+
+connection.delete();
+```
+
 ### Error Handling
 
 ```typescript

packages/duckdb/README.md

@@ -1,17 +1,51 @@
-# toJSON Method for MaterializedQueryResult
+# JSON Methods for DuckDB Results
 
-The `toJSON()` method has been added to `MaterializedQueryResult` to convert query results directly to a JSON string.
+This package provides two methods for converting query results to JSON:
 
-## Usage Example
+1. `MaterializedQueryResult.toJSON()` - Convert an existing result to JSON
+2. `Connection.queryToJSON(sql)` - Execute a query and get JSON in one call (recommended)
+
+## Usage Examples
+
+### Using queryToJSON (Recommended)
 
 ```javascript
 import { DuckDB } from '@hpcc-js/wasm-duckdb';
 
 const db = await DuckDB.load();
-const connection = await db.connect();
+const connection = db.connect();
+
+// Execute query and get JSON in one call
+const jsonString = connection.queryToJSON(`
+  SELECT 
+    id,
+    name,
+    age
+  FROM users
+  WHERE age > 18
+`);
+
+console.log(jsonString);
+// Output: [{"id":1,"name":"Alice","age":25},{"id":2,"name":"Bob","age":30}]
+
+// Parse back to JavaScript objects
+const data = JSON.parse(jsonString);
+console.log(data);
+// Output: [ { id: 1, name: 'Alice', age: 25 }, { id: 2, name: 'Bob', age: 30 } ]
+
+// No need to call result.delete() - it's handled automatically!
+```
+
+### Using toJSON on MaterializedQueryResult
+
+```javascript
+import { DuckDB } from '@hpcc-js/wasm-duckdb';
+
+const db = await DuckDB.load();
+const connection = db.connect();
 
 // Execute a query
-const result = await connection.query(`
+const result = connection.query(`
   SELECT 
     id,
     name,
@@ -25,15 +59,31 @@ const jsonString = result.toJSON();
 console.log(jsonString);
 // Output: [{"id":1,"name":"Alice","age":25},{"id":2,"name":"Bob","age":30}]
 
+// Must manually clean up
+result.delete();
+
 // Can be parsed back to JavaScript objects
 const data = JSON.parse(jsonString);
 console.log(data);
 // Output: [ { id: 1, name: 'Alice', age: 25 }, { id: 2, name: 'Bob', age: 30 } ]
 ```
 
+### When to Use Which Method
+
+**Use `queryToJSON()`** when:
+- You only need JSON output (most common case)
+- You want cleaner code with automatic cleanup
+- You're building APIs or data pipelines
+
+**Use `query()` + `toJSON()`** when:
+- You need to access individual values with `getValue()`
+- You need result metadata (row count, column types, etc.)
+- You need to perform multiple operations on the result
+
 ## Features
 
 - **Efficient JSON Encoding**: Converts entire result sets to JSON in C++ for better performance
+- **Automatic Memory Management**: `queryToJSON()` handles cleanup automatically
 - **Proper Type Handling**: 
   - Numbers (integers and floats)
   - Strings (with proper escaping)
@@ -42,6 +92,7 @@ console.log(data);
 - **Special Character Escaping**: Handles newlines, quotes, backslashes, tabs, and other special characters
 - **Multiple Rows**: Returns an array of objects, one per row
 - **Column Names**: Uses column names as JSON object keys
+- **Empty Results**: Returns `[]` for queries with no results
 
 ## Implementation Details
 

packages/duckdb/TOJSON.md

@@ -39,7 +39,7 @@
   },
   "dependencies": {},
   "devDependencies": {
-    "@hpcc-js/esbuild-plugins": "1.7.0",
+    "@hpcc-js/esbuild-plugins": "1.8.0",
     "@hpcc-js/wasm-util": "1.0.0"
   },
   "keywords": [

packages/duckdb/package.json

@@ -334,8 +334,17 @@ namespace ConnectionHelper
     {
         return obj.Query(query).release();
     }
-}
 
+    std::string queryToJSON(Connection &obj, const string &query)
+    {
+        auto result = obj.Query(query);
+        if (!result->HasError())
+        {
+            return MaterializedQueryResultHelper::toJSON(*result);
+        }
+        return std::string();
+    }
+}
 namespace DuckDBHelper
 {
     DuckDB *create()
@@ -476,6 +485,7 @@ EMSCRIPTEN_BINDINGS(duckdblib_bindings)
     class_<Connection>("Connection")
         .function("prepare", &ConnectionHelper::prepare, return_value_policy::take_ownership())
         .function("query", &ConnectionHelper::query, return_value_policy::take_ownership())
+        .function("queryToJSON", &ConnectionHelper::queryToJSON)
         .function("interrupt", &Connection::Interrupt)
         .function("getQueryProgress", &Connection::GetQueryProgress)
         // .function("enableProfiling", &Connection::EnableProfiling)

packages/duckdb/src-cpp/main.cpp

@@ -229,13 +229,61 @@ export class DuckDB extends MainModuleEx<MainModule> {
     registerFile(path: string, content: Uint8Array): void {
         const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
         const split = normalizedPath.lastIndexOf("/");
-        const dir = split > 0 ? normalizedPath.substring(0, split) : "/";
-        if (dir.length > 1 && this._module.FS_createPath) {
-            this._module.FS_createPath(dir, true, true);
+        if (split > 0) {
+            const dir = normalizedPath.substring(0, split);
+            const parts = dir.split("/");
+            let currentPath = "/";
+            for (const part of parts) {
+                if (part && this._module.FS_createPath) {
+                    this._module.FS_createPath(currentPath, part, true, true);
+                    currentPath = currentPath === "/" ? "/" + part : currentPath + "/" + part;
+                }
+            }
         }
         this._module.FS_createDataFile(normalizedPath, undefined, content, true, true, true);
     }
 
+    /**
+     * Unregisters and removes a file from the virtual file system.
+     * 
+     * This removes a file that was previously registered using {@link registerFile} or
+     * {@link registerFileString}. Once unregistered, the file will no longer be accessible
+     * to DuckDB queries.
+     * 
+     * The path is normalized to remove leading slashes before removal.
+     * 
+     * @param path - The path of the file to remove (e.g., "data/users.csv")
+     * 
+     * @example
+     * ```ts
+     * const duckdb = await DuckDB.load();
+     * 
+     * // Register a file
+     * duckdb.registerFileString("temp.csv", "id,name\n1,Alice");
+     * 
+     * const connection = duckdb.connect();
+     * let result = connection.query("SELECT * FROM read_csv_auto('temp.csv')");
+     * console.log(result.rowCount()); // 1
+     * result.delete();
+     * 
+     * // Unregister the file
+     * duckdb.unregisterFile("temp.csv");
+     * 
+     * // File is no longer accessible
+     * try {
+     *     result = connection.query("SELECT * FROM read_csv_auto('temp.csv')");
+     * } catch (error) {
+     *     console.error("File not found"); // Error: file not accessible
+     * }
+     * 
+     * connection.delete();
+     * ```
+     */
+    unregisterFile(path: string): void {
+        const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+        this._module.FS_unlink(normalizedPath);
+    }
+
     /**
      * Registers a text file in the virtual file system.
      *