@malloydata/db-duckdb 0.0.386 → 0.0.388

package/dist/duckdb_connection.d.ts

@@ -38,6 +38,12 @@ export declare class DuckDBConnection extends DuckDBCommon {
     protected connection: DuckDBNodeConnection | null;
     protected setupError: Error | undefined;
     protected isSetup: Promise<void> | undefined;
+    /**
+     * Set by `close()`. Once true, `setup()` throws and no operation will
+     * reattach. This is the "poison pill" that distinguishes terminal close
+     * from reversible idle.
+     */
+    protected closed: boolean;
     static activeDBs: Record<string, ActiveDB>;
     constructor(options: DuckDBConnectionOptions, queryOptions?: QueryOptionsReader);
     constructor(name: string, databasePath?: string, workingDirectory?: string, queryOptions?: QueryOptionsReader);
@@ -56,6 +62,14 @@ export declare class DuckDBConnection extends DuckDBCommon {
     }>;
     runSQLStream(sql: string, { rowLimit, abortSignal }?: RunSQLOptions): AsyncIterableIterator<QueryRecord>;
     close(): Promise<void>;
+    idle(): Promise<void>;
+    /**
+     * Remove this connection from the shared `activeDBs` entry. When the
+     * last connection sharing the entry is removed, close the underlying
+     * `DuckDBInstance` and drop the entry — releasing DuckDB's per-process
+     * file lock.
+     */
+    private detachInstance;
     /**
      * Forcefully close all cached DuckDB instances. Useful for test cleanup
      * to release file locks between test runs.

package/dist/duckdb_connection.js

@@ -36,6 +36,12 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         var _a;
         super();
         this.connection = null;
+        /**
+         * Set by `close()`. Once true, `setup()` throws and no operation will
+         * reattach. This is the "poison pill" that distinguishes terminal close
+         * from reversible idle.
+         */
+        this.closed = false;
         const options = typeof arg === 'string'
             ? buildLegacyOptions(arg, arg2, workingDirectory)
             : arg;
@@ -84,6 +90,9 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         }
     }
     async setup() {
+        if (this.closed) {
+            throw new Error(`DuckDB connection "${this.name}" is closed`);
+        }
         if (this.setupError) {
             throw this.setupError;
         }
@@ -91,6 +100,16 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         if (this.setupError) {
             throw this.setupError;
         }
+        // Lazy reattach after idle(): if our connection was released, re-run
+        // init() now. setupSQL gets replayed below because isSetup was cleared
+        // alongside the connection.
+        if (this.connection === null) {
+            this.connecting = this.init();
+            await this.connecting;
+            if (this.setupError) {
+                throw this.setupError;
+            }
+        }
         if (!this.isSetup) {
             this.isSetup = this.setupOnce();
         }
@@ -257,6 +276,31 @@ class DuckDBConnection extends duckdb_common_1.DuckDBCommon {
         }
     }
     async close() {
+        this.detachInstance();
+        this.connection = null;
+        this.isSetup = undefined;
+        this.setupError = undefined;
+        this.closed = true;
+    }
+    async idle() {
+        // No-op for in-memory: closing the instance silently destroys state.
+        if (this.normalized.databasePath === ':memory:')
+            return;
+        this.detachInstance();
+        this.connection = null;
+        this.isSetup = undefined;
+        this.setupError = undefined;
+        // Reattach is deferred — `setup()` detects the null connection on next
+        // use and runs a fresh init() then. Doing it eagerly here would
+        // re-acquire the lock immediately and defeat the point of idling.
+    }
+    /**
+     * Remove this connection from the shared `activeDBs` entry. When the
+     * last connection sharing the entry is removed, close the underlying
+     * `DuckDBInstance` and drop the entry — releasing DuckDB's per-process
+     * file lock.
+     */
+    detachInstance() {
         const activeDB = DuckDBConnection.activeDBs[this.shareKey];
         if (activeDB) {
             activeDB.connections = activeDB.connections.filter(connection => connection !== this.connection);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@malloydata/db-duckdb",
-  "version": "0.0.386",
+  "version": "0.0.388",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -60,7 +60,7 @@
   "dependencies": {
     "@duckdb/duckdb-wasm": "1.33.1-dev13.0",
     "@duckdb/node-api": "1.4.4-r.1",
-    "@malloydata/malloy": "0.0.386",
+    "@malloydata/malloy": "0.0.388",
     "@motherduck/wasm-client": "^0.6.6",
     "apache-arrow": "^17.0.0",
     "web-worker": "^1.3.0"