fix: prevent NullPool from destroying in-memory databases on Windows

The critical issue was using NullPool for ALL databases on Windows,
including in-memory databases. NullPool closes connections immediately
after use, which destroys in-memory SQLite databases, causing
"no such table" errors in tests.

Changes:
- Only use NullPool for FILESYSTEM databases on Windows
- In-memory databases now use regular connection pooling to maintain state
- Added error handling in _configure_sqlite_connection to prevent PRAGMA
  failures from breaking connections
- Added test to verify in-memory databases don't use NullPool

This should fix all Windows test failures while maintaining the benefits
of NullPool for filesystem databases on Windows.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>
Signed-off-by: phernandez <paul@basicmachines.co>

Author: phernandez

src/basic_memory/db.py

@@ -83,19 +83,24 @@ def _configure_sqlite_connection(dbapi_conn, enable_wal: bool = True) -> None:
         enable_wal: Whether to enable WAL mode (should be False for in-memory databases)
     """
     cursor = dbapi_conn.cursor()
-    # Enable WAL mode for better concurrency (not supported for in-memory databases)
-    if enable_wal:
-        cursor.execute("PRAGMA journal_mode=WAL")
-    # Set busy timeout to handle locked databases
-    cursor.execute("PRAGMA busy_timeout=10000")  # 10 seconds
-    # Optimize for performance
-    cursor.execute("PRAGMA synchronous=NORMAL")
-    cursor.execute("PRAGMA cache_size=-64000")  # 64MB cache
-    cursor.execute("PRAGMA temp_store=MEMORY")
-    # Windows-specific optimizations
-    if os.name == "nt":
-        cursor.execute("PRAGMA locking_mode=NORMAL")  # Ensure normal locking on Windows
-    cursor.close()
+    try:
+        # Enable WAL mode for better concurrency (not supported for in-memory databases)
+        if enable_wal:
+            cursor.execute("PRAGMA journal_mode=WAL")
+        # Set busy timeout to handle locked databases
+        cursor.execute("PRAGMA busy_timeout=10000")  # 10 seconds
+        # Optimize for performance
+        cursor.execute("PRAGMA synchronous=NORMAL")
+        cursor.execute("PRAGMA cache_size=-64000")  # 64MB cache
+        cursor.execute("PRAGMA temp_store=MEMORY")
+        # Windows-specific optimizations
+        if os.name == "nt":
+            cursor.execute("PRAGMA locking_mode=NORMAL")  # Ensure normal locking on Windows
+    except Exception as e:
+        # Log but don't fail - some PRAGMAs may not be supported
+        logger.warning(f"Failed to configure SQLite connection: {e}")
+    finally:
+        cursor.close()
 
 
 def _create_engine_and_session(
@@ -116,13 +121,19 @@ def _create_engine_and_session(
                 "isolation_level": None,  # Use autocommit mode
             }
         )
-        # Use NullPool for Windows to avoid connection pooling issues
-        engine = create_async_engine(
-            db_url,
-            connect_args=connect_args,
-            poolclass=NullPool,  # Disable connection pooling on Windows
-            echo=False,
-        )
+        # Use NullPool for Windows filesystem databases to avoid connection pooling issues
+        # Important: Do NOT use NullPool for in-memory databases as it will destroy the database
+        # between connections
+        if db_type == DatabaseType.FILESYSTEM:
+            engine = create_async_engine(
+                db_url,
+                connect_args=connect_args,
+                poolclass=NullPool,  # Disable connection pooling on Windows
+                echo=False,
+            )
+        else:
+            # In-memory databases need connection pooling to maintain state
+            engine = create_async_engine(db_url, connect_args=connect_args)
     else:
         engine = create_async_engine(db_url, connect_args=connect_args)
 
@@ -206,13 +217,19 @@ async def engine_session_factory(
                 "isolation_level": None,  # Use autocommit mode
             }
         )
-        # Use NullPool for Windows to avoid connection pooling issues
-        _engine = create_async_engine(
-            db_url,
-            connect_args=connect_args,
-            poolclass=NullPool,  # Disable connection pooling on Windows
-            echo=False,
-        )
+        # Use NullPool for Windows filesystem databases to avoid connection pooling issues
+        # Important: Do NOT use NullPool for in-memory databases as it will destroy the database
+        # between connections
+        if db_type == DatabaseType.FILESYSTEM:
+            _engine = create_async_engine(
+                db_url,
+                connect_args=connect_args,
+                poolclass=NullPool,  # Disable connection pooling on Windows
+                echo=False,
+            )
+        else:
+            # In-memory databases need connection pooling to maintain state
+            _engine = create_async_engine(db_url, connect_args=connect_args)
     else:
         _engine = create_async_engine(db_url, connect_args=connect_args)
 

test-int/test_db_wal_mode.py

@@ -123,3 +123,21 @@ async def test_regular_pool_on_non_windows(tmp_path):
         async with engine_session_factory(db_path, DatabaseType.FILESYSTEM) as (engine, _):
             # Engine should NOT be using NullPool on non-Windows
             assert not isinstance(engine.pool, NullPool)
+
+
+@pytest.mark.asyncio
+async def test_memory_database_no_null_pool_on_windows(tmp_path):
+    """Test that in-memory databases do NOT use NullPool even on Windows.
+
+    NullPool closes connections immediately, which destroys in-memory databases.
+    This test ensures in-memory databases maintain connection pooling.
+    """
+    from basic_memory.db import engine_session_factory, DatabaseType
+    from sqlalchemy.pool import NullPool
+
+    db_path = tmp_path / "test_memory.db"
+
+    with patch("basic_memory.db.os.name", "nt"):
+        async with engine_session_factory(db_path, DatabaseType.MEMORY) as (engine, _):
+            # In-memory databases should NOT use NullPool on Windows
+            assert not isinstance(engine.pool, NullPool)