feat: implement unregisterFile method

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

Author: GordonSmith

packages/duckdb/src/duckdb.ts

@@ -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.
      * 

packages/duckdb/tests/duckdb.spec.ts

@@ -357,6 +357,95 @@ describe("duckdb", () => {
             result.delete();
             con.delete();
         });
+
+        it("can unregister a file", () => {
+            const con = duckdb.connect();
+            const data = [{ id: 1, value: "test" }];
+
+            // Register file
+            duckdb.registerFileString("temp.json", JSON.stringify(data));
+
+            // Verify file is accessible
+            const result1 = con.query("SELECT * FROM read_json_auto('temp.json')");
+            expect(Number(result1.rowCount())).toBe(1);
+            result1.delete();
+
+            // Unregister file
+            duckdb.unregisterFile("temp.json");
+
+            // Verify file is no longer accessible
+            const result2 = con.query("SELECT * FROM read_json_auto('temp.json')");
+            expect(result2.hasError()).toBe(true);
+            expect(result2.getError()).toContain("temp.json");
+            result2.delete();
+
+            con.delete();
+        });
+
+        it("handles unregisterFile with leading slash", () => {
+            const con = duckdb.connect();
+
+            // Register without leading slash
+            duckdb.registerFileString("test.csv", "id\n1");
+
+            // Verify it's accessible
+            const result1 = con.query("SELECT * FROM read_csv_auto('test.csv')");
+            expect(Number(result1.rowCount())).toBe(1);
+            result1.delete();
+
+            // Unregister with leading slash
+            duckdb.unregisterFile("/test.csv");
+
+            // Verify file is no longer accessible
+            const result2 = con.query("SELECT * FROM read_csv_auto('test.csv')");
+            expect(result2.hasError()).toBe(true);
+            result2.delete();
+
+            con.delete();
+        });
+
+        it("can reregister a file after unregistering", () => {
+            const con = duckdb.connect();
+            const data1 = [{ value: "first" }];
+            const data2 = [{ value: "second" }];
+
+            // Register first version
+            duckdb.registerFileString("reuse.json", JSON.stringify(data1));
+            const result1 = con.query("SELECT * FROM read_json_auto('reuse.json')");
+            expect(result1.getValue(0, 0)).toBe("first");
+            result1.delete();
+
+            // Unregister
+            duckdb.unregisterFile("reuse.json");
+
+            // Register new version with same name
+            duckdb.registerFileString("reuse.json", JSON.stringify(data2));
+            const result2 = con.query("SELECT * FROM read_json_auto('reuse.json')");
+            expect(result2.getValue(0, 0)).toBe("second");
+            result2.delete();
+
+            con.delete();
+        });
+
+        it("unregisterFile handles nested paths", () => {
+            const con = duckdb.connect();
+
+            // Register file with nested path
+            duckdb.registerFileString("data/nested/file.json", JSON.stringify([{ id: 42 }]));
+
+            const result1 = con.query("SELECT * FROM read_json_auto('data/nested/file.json')");
+            expect(Number(result1.rowCount())).toBe(1);
+            result1.delete();
+
+            // Unregister nested file
+            duckdb.unregisterFile("data/nested/file.json");
+
+            const result2 = con.query("SELECT * FROM read_json_auto('data/nested/file.json')");
+            expect(result2.hasError()).toBe(true);
+            result2.delete();
+
+            con.delete();
+        });
     });
 
     describe("ErrorData handling", () => {