codegraph-engine 2.3.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

codegraph/indexing/parser.py

@@ -16,6 +16,7 @@ import json
 import posixpath
 import re
 from dataclasses import asdict, dataclass
+from typing import cast
 
 from codegraph.frameworks import (
     AnalysisContext,
@@ -27,6 +28,9 @@ from codegraph.frameworks import (
     analyze_js_ts_mounts,
     get_python_analyzers,
 )
+from codegraph.frameworks_nestjs import analyze_nestjs_file
+from codegraph.frameworks_nextjs import analyze_nextjs_file
+from codegraph.frameworks_react import analyze_react_file
 from codegraph.semantic_decorators import analyze_symbol_decorators
 
 from .models import (
@@ -215,6 +219,30 @@ def parse(content: str, language: str, file_path: str) -> ParseResult:
     """Parse a source file in a single scoped pass."""
     if language == "python":
         return _parse_python(content, file_path)
+    if language == "luau" or file_path.lower().endswith((".lua", ".luau")):
+        from codegraph.roblox import parse_luau
+        return parse_luau(content, file_path)
+    if language == "go" or file_path.lower().endswith(".go"):
+        from codegraph.indexing.languages.go import parse_go
+        return cast(ParseResult, parse_go(content, file_path))
+    if language == "rust" or file_path.lower().endswith(".rs"):
+        from codegraph.indexing.languages.rust import parse_rust
+        return cast(ParseResult, parse_rust(content, file_path))
+    if language in ("java", "kotlin") or file_path.lower().endswith((".java", ".kt", ".kts")):
+        from codegraph.indexing.languages.jvm import parse_jvm
+        return cast(ParseResult, parse_jvm(content, file_path))
+    if language in ("c", "cpp", "c_header", "cpp_header") or file_path.lower().endswith((".c", ".cc", ".cpp", ".cxx", ".h", ".hpp", ".hxx")):
+        from codegraph.indexing.languages.cpp import parse_cpp
+        return cast(ParseResult, parse_cpp(content, file_path))
+    if language == "proto" or file_path.lower().endswith(".proto"):
+        from codegraph.indexing.protocols import parse_proto
+        return cast(ParseResult, parse_proto(content, file_path))
+    if language == "graphql" or file_path.lower().endswith((".graphql", ".gql")):
+        from codegraph.indexing.protocols import parse_graphql
+        return cast(ParseResult, parse_graphql(content, file_path))
+    if language == "html" or file_path.lower().endswith((".html", ".htm", ".jinja", ".jinja2", ".njk", ".ejs")):
+        from codegraph.indexing.templates import parse_html_template
+        return parse_html_template(content, file_path)
     if language in ("sql", "prisma"):
         source_hash = hashlib.sha256(content.encode("utf-8", errors="replace")).hexdigest()
         return ParseResult(
@@ -434,6 +462,7 @@ class _PythonScopeVisitor(ast.NodeVisitor):
         self.bindings: list[BindingRef] = []
         self.exports: list[str] = []
         self.conditional_depth: int = 0
+        self.di_type_aliases: dict[str, str] = {}
 
         # Scope stack: (name, kind, qualified_name, canonical_id)
         self.scope_stack: list[tuple[str, str, str, str]] = []
@@ -825,6 +854,36 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                                     dep_expr = ast.unparse(elts[0]).split("[")[0].strip()
                                 break
 
+            # Check if annotation refers to an Annotated type alias: e.g. session: SessionDep, current_user: CurrentUser
+            if not dep_expr and arg.annotation and hasattr(ast, "unparse"):
+                ann_text = ast.unparse(arg.annotation).strip()
+                ann_short = ann_text.split("[")[0].strip().split(".")[-1]
+                if ann_short in self.di_type_aliases:
+                    dep_expr = self.di_type_aliases[ann_short]
+                elif (
+                    ann_short not in _PYTHON_BUILTINS
+                    and not ann_short.startswith("_")
+                    and ann_short not in (
+                        "Any", "Optional", "Union", "List", "Dict", "Set", "Tuple",
+                        "int", "str", "float", "bool", "bytes", "dict", "list", "set", "tuple",
+                    )
+                ):
+                    self.bindings.append(
+                        BindingRef(
+                            target_name=canon_id,
+                            file_path=self.file_path,
+                            line=node.lineno,
+                            column=getattr(node, "col_offset", None),
+                            scope=self.current_scope_qname,
+                            expr_kind="PARAM_TYPE_DI",
+                            source_expr=ann_text,
+                            is_conditional=is_cond,
+                            base_expr="fastapi",
+                            attr_name="Depends",
+                            subscript_key=json.dumps({"param": arg.arg, "alias": ann_short, "framework": "fastapi"}),
+                        )
+                    )
+
             if dep_expr:
                 self.bindings.append(
                     BindingRef(
@@ -1354,12 +1413,104 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                     )
                 )
 
+        # 10. Modern FastAPI / typing Annotated DI alias
+        # e.g., SessionDep = Annotated[Session, Depends(get_db)]
+        #       CurrentUser = Annotated[User, Depends(get_current_user)]
+        #       TokenDep = Annotated[str, Depends(reusable_oauth2)]
+        if isinstance(value_node, ast.Subscript) and hasattr(ast, "unparse"):
+            val_id = getattr(value_node.value, "id", None) or (
+                getattr(value_node.value, "attr", None) if isinstance(value_node.value, ast.Attribute) else ""
+            )
+            val_unparse = ast.unparse(value_node.value) if hasattr(ast, "unparse") else ""
+            if val_id in ("Annotated", "typing.Annotated", "typing_extensions.Annotated") or "Annotated" in val_unparse:
+                slice_node = value_node.slice
+                elts = slice_node.elts if isinstance(slice_node, (ast.Tuple, ast.List)) else [slice_node]
+                for elt in elts[1:]:
+                    if isinstance(elt, ast.Call):
+                        f_nm = getattr(elt.func, "id", None) or (
+                            getattr(elt.func, "attr", None) if isinstance(elt.func, ast.Attribute) else ""
+                        )
+                        if f_nm == "Depends":
+                            elt_arg: ast.expr | None = elt.args[0] if elt.args else None
+                            if elt_arg is None:
+                                elt_kw = next((kw for kw in elt.keywords if kw.arg == "dependency"), None)
+                                if elt_kw is not None:
+                                    elt_arg = elt_kw.value
+                            dep_alias_str: str | None = None
+                            if elt_arg is not None:
+                                if isinstance(elt_arg, (ast.Name, ast.Attribute)):
+                                    dep_alias_str = ast.unparse(elt_arg)
+                                else:
+                                    dep_alias_str = "<DYNAMIC>"
+                            elif hasattr(ast, "unparse"):
+                                dep_alias_str = ast.unparse(elts[0]).split("[")[0].strip()
+                            if dep_alias_str:
+                                self.di_type_aliases[target_name] = dep_alias_str
+                                self.bindings.append(
+                                    BindingRef(
+                                        target_name=target_name,
+                                        file_path=self.file_path,
+                                        line=line,
+                                        column=col,
+                                        scope=scope,
+                                        expr_kind="DI_ALIAS_INJECTS",
+                                        source_expr=dep_alias_str,
+                                        is_conditional=is_cond,
+                                        base_expr="fastapi",
+                                        attr_name="Depends",
+                                        subscript_key=json.dumps({"alias": target_name, "framework": "fastapi"}),
+                                    )
+                                )
+                            break
+
     def visit_Assign(self, node: ast.Assign) -> None:
         for target in node.targets:
             if isinstance(target, ast.Name):
                 self._extract_binding_from_assign(
                     target.id, node.value, node.lineno, getattr(node, "col_offset", None)
                 )
+                if target.id in ("template_name", "template") and isinstance(node.value, ast.Constant) and isinstance(node.value.value, str):
+                    self.bindings.append(
+                        BindingRef(
+                            target_name=node.value.value,
+                            file_path=self.file_path,
+                            line=node.lineno,
+                            column=getattr(node, "col_offset", None),
+                            scope=self.current_scope_qname or "",
+                            expr_kind="RENDERS_TEMPLATE",
+                            base_expr=self.current_scope_canonical_id or "",
+                            source_expr=node.value.value,
+                        )
+                    )
+                elif isinstance(node.value, ast.BinOp) and isinstance(node.value.op, ast.BitOr):
+                    # Unfold bitwise OR chain (e.g. prompt | llm | output_parser)
+                    pipe_steps: list[str] = []
+                    curr: ast.expr = node.value
+                    is_valid_pipe = True
+                    while isinstance(curr, ast.BinOp) and isinstance(curr.op, ast.BitOr):
+                        r_text = ast.unparse(curr.right).strip() if hasattr(ast, "unparse") else ""
+                        if not r_text or isinstance(curr.right, ast.Constant):
+                            is_valid_pipe = False
+                            break
+                        pipe_steps.append(r_text)
+                        curr = curr.left
+                    l_text = ast.unparse(curr).strip() if hasattr(ast, "unparse") else ""
+                    if is_valid_pipe and l_text and not isinstance(curr, ast.Constant):
+                        pipe_steps.append(l_text)
+                        pipe_steps.reverse()
+                        if len(pipe_steps) >= 2:
+                            self.bindings.append(
+                                BindingRef(
+                                    target_name=target.id,
+                                    file_path=self.file_path,
+                                    line=node.lineno,
+                                    column=getattr(node, "col_offset", None),
+                                    scope=self.current_scope_qname or "",
+                                    expr_kind="LCEL_PIPELINE",
+                                    base_expr="|".join(pipe_steps),
+                                    source_expr=json.dumps(pipe_steps),
+                                )
+                            )
             elif (
                 isinstance(target, ast.Attribute)
                 and isinstance(target.value, ast.Name)
@@ -1575,6 +1726,39 @@ class _PythonScopeVisitor(ast.NodeVisitor):
         caller_canon = self.current_scope_canonical_id
         end_ln = node.end_lineno or node.lineno
 
+        # Python View -> Template rendering (Flask render_template, Django render, FastAPI TemplateResponse)
+        template_name: str | None = None
+        if isinstance(node.func, ast.Name):
+            if node.func.id == "render_template" and node.args:
+                if isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                    template_name = node.args[0].value
+            elif node.func.id == "render" and len(node.args) >= 2:
+                if isinstance(node.args[1], ast.Constant) and isinstance(node.args[1].value, str):
+                    template_name = node.args[1].value
+        elif isinstance(node.func, ast.Attribute):
+            if node.func.attr == "TemplateResponse" and node.args:
+                if isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                    template_name = node.args[0].value
+                elif len(node.args) >= 2 and isinstance(node.args[1], ast.Constant) and isinstance(node.args[1].value, str):
+                    template_name = node.args[1].value
+                for kw in node.keywords:
+                    if kw.arg in ("name", "template_name") and isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                        template_name = kw.value.value
+
+        if template_name:
+            self.bindings.append(
+                BindingRef(
+                    target_name=template_name,
+                    file_path=self.file_path,
+                    line=node.lineno,
+                    column=getattr(node, "col_offset", None),
+                    scope=caller_qname or "",
+                    expr_kind="RENDERS_TEMPLATE",
+                    base_expr=caller_canon or "",
+                    source_expr=template_name,
+                )
+            )
+
         if isinstance(node.func, ast.Name):
             callee_name = node.func.id
             if callee_name == "subscribe" and len(node.args) >= 2 and hasattr(ast, "unparse"):
@@ -2010,6 +2194,106 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                             subscript_key=ev_str,
                         )
                     )
+            # Celery / Background task / Ray remote task invocation (.delay(), .apply_async(), .s(), .si(), .signature(), .remote())
+            if attr_name in ("delay", "apply_async", "s", "si", "signature", "remote"):
+                task_callee = recv_clean.split(".")[-1]
+                if task_callee and task_callee not in ("self", "cls"):
+                    self.calls.append(
+                        CallRef(
+                            callee=task_callee,
+                            qualified_callee=recv_clean,
+                            line=node.lineno,
+                            end_line=end_ln,
+                            source_file=self.file_path,
+                            confidence="HIGH",
+                            caller_symbol=caller_qname,
+                            caller_canonical_id=caller_canon,
+                            receiver=recv_clean if "." in recv_clean else None,
+                        )
+                    )
+                    dispatch_kind = "RAY_REMOTE" if attr_name == "remote" else "CELERY_DISPATCH"
+                    self.bindings.append(
+                        BindingRef(
+                            target_name=task_callee,
+                            file_path=self.file_path,
+                            line=node.lineno,
+                            column=getattr(node, "col_offset", None),
+                            scope=caller_qname or "",
+                            expr_kind=dispatch_kind,
+                            base_expr=attr_name,
+                            source_expr=recv_clean,
+                        )
+                    )
+            elif attr_name == "send_task" and node.args and isinstance(node.args[0], ast.Constant) and isinstance(node.args[0].value, str):
+                full_task = node.args[0].value
+                task_short = full_task.split(".")[-1]
+                self.calls.append(
+                    CallRef(
+                        callee=task_short,
+                        qualified_callee=full_task,
+                        line=node.lineno,
+                        end_line=end_ln,
+                        source_file=self.file_path,
+                        confidence="HIGH",
+                        caller_symbol=caller_qname,
+                        caller_canonical_id=caller_canon,
+                        receiver=full_task if "." in full_task else None,
+                    )
+                )
+                self.bindings.append(
+                    BindingRef(
+                        target_name=task_short,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=caller_qname or "",
+                        expr_kind="CELERY_DISPATCH",
+                        base_expr="send_task",
+                        source_expr=full_task,
+                    )
+                )
+            elif attr_name == "connect" and node.args and hasattr(ast, "unparse"):
+                receiver_node = node.args[0]
+                receiver_name = ast.unparse(receiver_node).strip()
+                sender_name = ""
+                for kw in node.keywords:
+                    if kw.arg == "sender":
+                        if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                            sender_name = kw.value.value
+                        elif isinstance(kw.value, (ast.Name, ast.Attribute)):
+                            sender_name = ast.unparse(kw.value).strip()
+                self.bindings.append(
+                    BindingRef(
+                        target_name=receiver_name,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=self.current_scope_qname or "",
+                        expr_kind="DJANGO_SIGNAL_RECEIVER",
+                        base_expr=recv_clean,
+                        source_expr=sender_name,
+                    )
+                )
+            elif attr_name in ("send", "send_robust") and hasattr(ast, "unparse"):
+                sender_name = ""
+                for kw in node.keywords:
+                    if kw.arg == "sender":
+                        if isinstance(kw.value, ast.Constant) and isinstance(kw.value.value, str):
+                            sender_name = kw.value.value
+                        elif isinstance(kw.value, (ast.Name, ast.Attribute)):
+                            sender_name = ast.unparse(kw.value).strip()
+                self.bindings.append(
+                    BindingRef(
+                        target_name=recv_clean,
+                        file_path=self.file_path,
+                        line=node.lineno,
+                        column=getattr(node, "col_offset", None),
+                        scope=self.current_scope_qname or "",
+                        expr_kind="DJANGO_SIGNAL_SEND",
+                        base_expr=attr_name,
+                        source_expr=sender_name,
+                    )
+                )
 
             q_callee = f"{resolved_recv}.{attr_name}" if resolved_recv else attr_name
             self.calls.append(
@@ -2042,6 +2326,26 @@ class _PythonScopeVisitor(ast.NodeVisitor):
                 )
             )
 
+        # Agent tool registration (e.g. AgentExecutor(tools=[...]), create_openai_tools_agent(..., tools=[...]))
+        for kw in node.keywords:
+            if kw.arg in ("tools", "functions") and isinstance(kw.value, (ast.List, ast.Tuple)):
+                func_label = ast.unparse(node.func).strip() if hasattr(ast, "unparse") else ""
+                for elt in kw.value.elts:
+                    t_name = ast.unparse(elt).strip() if hasattr(ast, "unparse") else ""
+                    if t_name:
+                        self.bindings.append(
+                            BindingRef(
+                                target_name=t_name,
+                                file_path=self.file_path,
+                                line=node.lineno,
+                                column=getattr(node, "col_offset", None),
+                                scope=caller_qname or "",
+                                expr_kind="AGENT_TOOL_REGISTRATION",
+                                base_expr=func_label,
+                                source_expr=t_name,
+                            )
+                        )
+
         self.generic_visit(node)
 
 
@@ -2096,19 +2400,47 @@ def _extract_all_python_imports(
     return imports
 
 
+def _repair_python_syntax(content: str) -> str:
+    """Repair common syntax patterns from newer or experimental Python versions (e.g. unparenthesized multiple except)."""
+    lines = content.splitlines()
+    repaired = False
+    new_lines = []
+    for line in lines:
+        # Match 'except A, B:' or 'except A, B as e:' or 'except* A, B:' without enclosing parentheses
+        m = re.match(
+            r'^(\s*except\*?\s+)([A-Za-z0-9_.\s]+,\s*[A-Za-z0-9_.,\s]+?)(\s+as\s+[A-Za-z0-9_]+)?(\s*:.*)$',
+            line,
+        )
+        if m:
+            prefix, types, as_part, suffix = m.group(1), m.group(2).strip(), m.group(3) or "", m.group(4)
+            if not types.startswith("("):
+                line = f"{prefix}({types}){as_part}{suffix}"
+                repaired = True
+        new_lines.append(line)
+    return "\n".join(new_lines) if repaired else content
+
+
 def _parse_python(content: str, file_path: str) -> ParseResult:
     source_hash = hashlib.sha256(content.encode("utf-8", errors="replace")).hexdigest()
+    tree: ast.Module | None = None
     try:
         tree = ast.parse(content)
     except SyntaxError as exc:
-        return ParseResult(
-            path=file_path,
-            language="python",
-            source_hash=source_hash,
-            imports=tuple(_py_imports_fallback(content, file_path)),
-            parse_failed=True,
-            parse_error=f"SyntaxError at line {exc.lineno}: {exc.msg}",
-        )
+        repaired = _repair_python_syntax(content)
+        if repaired != content:
+            try:
+                tree = ast.parse(repaired)
+            except SyntaxError:
+                tree = None
+        if tree is None:
+            return ParseResult(
+                path=file_path,
+                language="python",
+                source_hash=source_hash,
+                imports=tuple(_py_imports_fallback(content, file_path)),
+                parse_failed=True,
+                parse_error=f"SyntaxError at line {exc.lineno}: {exc.msg}",
+            )
 
     # First collect import module names cheaply from top-level imports to configure analyzers
     import_mods: set[str] = set()
@@ -2732,7 +3064,7 @@ def _parse_js_ts(content: str, language: str, file_path: str) -> ParseResult:
                             )
 
         # Route detection hook per line (Express and Next.js)
-        detected_routes = analyze_js_ts_line(line, lineno, file_path, module, import_mods_set)
+        detected_routes = analyze_js_ts_line(line, lineno, file_path, module, import_mods_set, lines, idx)
         if detected_routes:
             routes.extend(detected_routes)
         detected_mounts = analyze_js_ts_mounts(line, lineno, file_path, module)
@@ -3013,6 +3345,50 @@ def _parse_js_ts(content: str, language: str, file_path: str) -> ParseResult:
                     )
                 )
 
+    # Framework file-level enhancements (NestJS and Next.js)
+    if "@" in content:
+        nest_res = analyze_nestjs_file(content, file_path, module)
+        if nest_res.routes:
+            routes.extend(nest_res.routes)
+        if nest_res.mounts:
+            mounts.extend(nest_res.mounts)
+        if nest_res.bindings:
+            bindings.extend(nest_res.bindings)
+
+    next_res = analyze_nextjs_file(content, file_path, module)
+    if next_res.routes:
+        seen_ep_ids = {r.endpoint_id for r in routes}
+        for nr in next_res.routes:
+            if nr.endpoint_id not in seen_ep_ids:
+                routes.append(nr)
+                seen_ep_ids.add(nr.endpoint_id)
+    if next_res.bindings:
+        bindings.extend(next_res.bindings)
+
+    # React and JSX component architecture (Pillar 4)
+    react_res = analyze_react_file(content, file_path, module)
+    sym_indices = {s.canonical_id: i for i, s in enumerate(symbols)}
+    for sym in react_res.components:
+        if sym.canonical_id in sym_indices:
+            symbols[sym_indices[sym.canonical_id]] = sym
+        else:
+            seen_canonical.add(sym.canonical_id)
+            symbols.append(sym)
+    for h_sym in react_res.hooks:
+        if h_sym.canonical_id in sym_indices:
+            symbols[sym_indices[h_sym.canonical_id]] = h_sym
+        else:
+            seen_canonical.add(h_sym.canonical_id)
+            symbols.append(h_sym)
+    if react_res.bindings:
+        bindings.extend(react_res.bindings)
+
+    if language == "typescript" and ("@Service" in content or "@Controller" in content or "Dependency<" in content):
+        from codegraph.roblox import extract_flamework_bindings
+        fw_bindings = extract_flamework_bindings(content, file_path, module)
+        if fw_bindings:
+            bindings.extend(fw_bindings)
+
     symbols.sort(key=lambda s: (s.start_line, s.canonical_id))
     return ParseResult(
         path=file_path,

codegraph/indexing/pool.py

@@ -0,0 +1,136 @@
+"""Thread-safe SQLite connection pool for concurrent MCP and CLI execution."""
+from __future__ import annotations
+
+import queue
+import sqlite3
+import threading
+from collections.abc import Callable
+from pathlib import Path
+
+from .classifier import make_compat_row
+
+
+class SQLiteConnectionPool:
+    """Thread-safe, re-entrant connection pool for SQLite databases.
+
+    Features:
+    - Thread-safe LIFO pool to maximize SQLite cache reuse.
+    - WAL mode, synchronous=NORMAL, foreign_keys=ON, busy_timeout=30000ms.
+    - check_same_thread=False for cross-thread pool handoff.
+    - Re-entrant per-thread acquisition (nesting depth tracking via thread-local state).
+    - Optional initializer hook for idempotent schema / setup execution.
+    """
+
+    def __init__(
+        self,
+        db_path: Path | str,
+        max_size: int = 16,
+        timeout: float = 30.0,
+        initializer: Callable[[sqlite3.Connection], None] | None = None,
+    ) -> None:
+        self.db_path = Path(db_path) if isinstance(db_path, str) else db_path
+        self.max_size = max(1, max_size)
+        self.timeout = timeout
+        self.initializer = initializer
+        self._pool: queue.LifoQueue[sqlite3.Connection] = queue.LifoQueue()
+        self._created = 0
+        self._lock = threading.Lock()
+        self._local = threading.local()
+
+    def _create_connection(self) -> sqlite3.Connection:
+        con = sqlite3.connect(
+            self.db_path,
+            check_same_thread=False,
+            timeout=self.timeout,
+        )
+        con.row_factory = make_compat_row
+        con.execute("PRAGMA journal_mode = WAL")
+        con.execute("PRAGMA synchronous = NORMAL")
+        con.execute("PRAGMA foreign_keys = ON")
+        con.execute("PRAGMA busy_timeout = 30000")
+        con.execute("PRAGMA cache_size = -64000")
+        con.execute("PRAGMA temp_store = MEMORY")
+        if self.initializer is not None:
+            self.initializer(con)
+        return con
+
+    def acquire(self) -> tuple[sqlite3.Connection, bool]:
+        """Acquire a connection. Returns (connection, is_owner).
+
+        If the current thread already holds a connection from this pool,
+        it increments the re-entrancy depth and returns (connection, False).
+        """
+        active_con = getattr(self._local, "con", None)
+        if active_con is not None:
+            self._local.nesting = getattr(self._local, "nesting", 0) + 1
+            return active_con, False
+
+        con: sqlite3.Connection | None = None
+        try:
+            con = self._pool.get_nowait()
+        except queue.Empty:
+            with self._lock:
+                if self._created < self.max_size:
+                    con = self._create_connection()
+                    self._created += 1
+
+            if con is None:
+                con = self._pool.get(timeout=self.timeout)
+
+        self._local.con = con
+        self._local.nesting = 1
+        return con, True
+
+    def release(
+        self,
+        con: sqlite3.Connection,
+        is_owner: bool,
+        rollback: bool = False,
+    ) -> None:
+        """Release a connection back to the pool."""
+        if not is_owner:
+            cur_nesting = getattr(self._local, "nesting", 1) - 1
+            self._local.nesting = max(0, cur_nesting)
+            if rollback:
+                try:
+                    con.rollback()
+                except Exception:
+                    pass
+            return
+
+        self._local.con = None
+        self._local.nesting = 0
+        if rollback:
+            try:
+                con.rollback()
+            except Exception:
+                pass
+        else:
+            try:
+                con.commit()
+            except Exception:
+                pass
+
+        try:
+            self._pool.put_nowait(con)
+        except Exception:
+            try:
+                con.close()
+            except Exception:
+                pass
+
+    def close_all(self) -> None:
+        """Close and dispose all connections in the pool."""
+        with self._lock:
+            while True:
+                try:
+                    con = self._pool.get_nowait()
+                    try:
+                        con.close()
+                    except Exception:
+                        pass
+                except queue.Empty:
+                    break
+            self._created = 0
+            self._local.con = None
+            self._local.nesting = 0