quantum-framework 0.16.0__tar.gz → 0.17.0__tar.gz

{quantum_framework-0.16.0/quantum_framework.egg-info → quantum_framework-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.16.0
+Version: 0.17.0
 Summary: Full-stack declarative framework for building web, desktop, and mobile applications
 Author-email: Daniel Gregorio <danielgregorio2611@gmail.com>
 License: MIT

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.16.0"
+version = "0.17.0"
 description = "Full-stack declarative framework for building web, desktop, and mobile applications"
 readme = "README.md"
 license = {text = "MIT"}

quantum_framework-0.17.0/quantum/cli/check.py

@@ -0,0 +1,202 @@
+"""`quantum check`: every page parses, every q:query compiles against the database,
+and every `{query.field}` a page reads is a column the query returns (M8, DEV-3).
+
+A typo in SQL or in a field name used to surface only when someone opened the
+page — `no such column` as a 500, or, for a field, an empty cell. This reads
+the project the way the server would and reports each problem with its file
+and line, without running anything: a query is compiled by the database
+(EXPLAIN) and a SELECT's columns come from running it with LIMIT 0.
+"""
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Dict, Iterator, List, Optional
+
+# Fields of `<name>_result` and of a query row that are not columns.
+_META = {'recordCount', 'columnList', 'executionTime', 'success', 'error', 'sql', 'page',
+         'totalPages', 'hasMore', 'cached', 'affectedRows', 'lastInsertId', 'data', 'length'}
+_EXPR = re.compile(r'\{([^{}]*)\}')
+
+
+@dataclass
+class Problem:
+    file: str
+    line: Optional[int]
+    message: str
+
+    def __str__(self) -> str:
+        return f'{self.file}:{self.line or "?"}: {self.message}'
+
+
+def _config(config_path: Path) -> dict:
+    import yaml
+    from quantum.core.config_env import expand_env
+    if not config_path.exists():
+        return {}
+    return expand_env(yaml.safe_load(config_path.read_text(encoding='utf-8')) or {})
+
+
+def _children(node) -> Iterator:
+    """The nodes inside a node, whatever the field is called."""
+    for campo in ('statements', 'body', 'if_body', 'else_body', 'children'):
+        for filho in getattr(node, campo, None) or []:
+            if hasattr(filho, '__dict__'):
+                yield filho
+    for bloco in getattr(node, 'elseif_blocks', None) or []:
+        corpo = bloco.get('body') if isinstance(bloco, dict) else getattr(bloco, 'body', None)
+        for filho in corpo or []:
+            yield filho
+
+
+def _texts(node) -> List[str]:
+    """The strings of a node that may hold {expressions}."""
+    textos = []
+    for campo, valor in vars(node).items():
+        if campo.startswith('_') or campo in ('sql',):
+            continue
+        if isinstance(valor, str) and '{' in valor:
+            textos.append(valor)
+        elif isinstance(valor, dict):
+            textos += [v for v in valor.values() if isinstance(v, str) and '{' in v]
+    return textos
+
+
+class ProjectChecker:
+    def __init__(self, project: Path, config_path: Path):
+        self.project = project
+        self.config = _config(config_path)
+        self.datasources = self.config.get('datasources') or {}
+        self._conexoes: Dict[str, object] = {}
+        self.problems: List[Problem] = []
+        self.notes: List[str] = []
+        self.queries_checked = 0
+        self.files = 0
+
+    # -- the database ---------------------------------------------------------
+
+    def _connection(self, nome: str):
+        from quantum.runtime.db_schema import SchemaError, connect_readonly
+        if nome not in self._conexoes:
+            try:
+                self._conexoes[nome] = connect_readonly(self.datasources[nome], self.project)
+            except SchemaError as exc:
+                self._conexoes[nome] = None
+                self.notes.append(f'datasource {nome!r} not checked: {exc}')
+        return self._conexoes[nome]
+
+    # -- a file ---------------------------------------------------------------
+
+    def check_file(self, arquivo: Path) -> None:
+        from quantum.core.parser import QuantumParser
+        rel = arquivo.relative_to(self.project).as_posix() if arquivo.is_relative_to(self.project) else str(arquivo)
+        self.files += 1
+        try:
+            ast = QuantumParser(use_cache=False).parse_file(str(arquivo))
+        except Exception as exc:        # a parse error is a problem like any other
+            primeira = str(exc).split('\n')[0]
+            self.problems.append(Problem(rel, getattr(exc, 'line', None), primeira))
+            return
+        colunas: Dict[str, List[str]] = {}
+        self._queries(ast, rel, colunas)
+        self._fields(ast, rel, colunas, {nome: nome for nome in colunas}, None)
+
+    def _queries(self, node, rel: str, colunas: Dict[str, List[str]]) -> None:
+        from quantum.core.ast_nodes import QueryNode
+        from quantum.runtime.db_schema import check_sql
+        for filho in _children(node):
+            if isinstance(filho, QueryNode):
+                ds = filho.datasource
+                if not ds or ds.startswith('knowledge:') or getattr(filho, 'source', None):
+                    pass                                 # RAG or query of queries: not SQL on a database
+                elif ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                 f'<q:query name="{filho.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                else:
+                    conexao = self._connection(ds)
+                    if conexao is not None:
+                        self.queries_checked += 1
+                        erro, cols = check_sql(conexao, filho.sql or '')
+                        if erro:
+                            self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                         f'<q:query name="{filho.name}">: {erro}'))
+                        elif cols is not None:
+                            colunas[filho.name] = cols
+            self._queries(filho, rel, colunas)
+
+    def _fields(self, node, rel: str, colunas: Dict[str, List[str]], ligados: Dict[str, str],
+                linha: Optional[int]) -> None:
+        """Each `{var.field}` where var is a query, or a row of one, names a column it returns."""
+        from quantum.core.features.loops.src.ast_node import LoopNode
+        from quantum.core.features.ui_engine.src.ast_nodes import UIColumnNode, UIListNode, UITableNode
+        linha = getattr(node, 'source_line', None) or linha
+        for texto in _texts(node):
+            for expressao in _EXPR.findall(texto):
+                for var, campo in re.findall(r'(?<![\w.])(\w+)\.(\w+)', expressao):
+                    self._field(rel, linha, colunas, ligados, var, campo)
+        if isinstance(node, UIColumnNode) and node.key and '$tabela' in ligados:
+            self._field(rel, linha, colunas, ligados, '$tabela', node.key, f'<ui:column key="{node.key}">')
+
+        for filho in _children(node):
+            dentro = dict(ligados)
+            origem = None
+            if isinstance(filho, LoopNode):
+                origem = filho.query_name if filho.loop_type == 'query' else _single_name(filho.items)
+                if origem in colunas:
+                    dentro[filho.var_name] = origem
+            elif isinstance(filho, (UITableNode, UIListNode)):
+                origem = _single_name(filho.source)
+                if origem in colunas:
+                    dentro[filho.as_var or ('row' if isinstance(filho, UITableNode) else 'item')] = origem
+                    if isinstance(filho, UITableNode):
+                        dentro['$tabela'] = origem
+            self._fields(filho, rel, colunas, dentro, linha)
+
+    def _field(self, rel, linha, colunas, ligados, var, campo, como=None) -> None:
+        consulta = ligados.get(var)
+        if consulta is None or campo in _META:
+            return
+        cols = colunas.get(consulta, [])
+        if campo not in cols:
+            quem = como or f'{{{var}.{campo}}}'
+            self.problems.append(Problem(
+                rel, linha, f'{quem}: query "{consulta}" returns no column "{campo}" '
+                            f'(columns: {", ".join(cols) or "none"})'))
+
+    # -- the project ----------------------------------------------------------
+
+    def run(self) -> List[Problem]:
+        pasta = self.project / (self.config.get('paths', {}) or {}).get('components', 'components')
+        if not pasta.exists():
+            self.notes.append(f'no components folder at {pasta}')
+            return self.problems
+        for arquivo in sorted(pasta.rglob('*.q')):
+            self.check_file(arquivo)
+        for conexao in self._conexoes.values():
+            if conexao is not None:
+                conexao.close()
+        return self.problems
+
+
+def _single_name(expr: Optional[str]) -> Optional[str]:
+    """`{tarefas}` -> 'tarefas'; anything more complex -> None."""
+    m = re.fullmatch(r'\s*\{\s*(\w+)\s*\}\s*', expr or '')
+    return m.group(1) if m else None
+
+
+def run_check(config_path: str = 'quantum.config.yaml') -> int:
+    """`quantum check`: print each problem as file:line: message; exit 1 if there is any."""
+    caminho = Path(config_path).resolve()
+    checker = ProjectChecker(caminho.parent, caminho)
+    problemas = checker.run()
+    for nota in checker.notes:
+        print(f'[NOTE] {nota}')
+    for problema in problemas:
+        print(problema)
+    resumo = (f'{checker.files} file(s), {checker.queries_checked} query(ies) checked against the database')
+    if problemas:
+        print(f'\n{len(problemas)} problem(s) — {resumo}.')
+        return 1
+    print(f'OK — {resumo}.')
+    return 0

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/cli/runner.py

@@ -287,6 +287,7 @@ Examples:
   quantum admin                    # Start the Quantum Admin
   quantum console                  # The application's pages in the terminal
   quantum desktop                  # The application's pages in a desktop window
+  quantum check                    # Pages parse, SQL compiles, query fields exist
   quantum run game.q --engine godot # Build Godot 4 project
   quantum run backup-job.q         # Execute job
   quantum deploy ./my-app          # Deploy application
@@ -342,6 +343,10 @@ Examples:
     console_parser.add_argument('path', nargs='?', default='/', help='Page to open (default: /)')
     console_parser.add_argument('--config', default='quantum.config.yaml', help='Config file')
 
+    # Check: pages parse, queries compile, fields exist (M8, DEV-3)
+    check_parser = subparsers.add_parser('check', help='Check pages, SQL and query fields against the database')
+    check_parser.add_argument('--config', default='quantum.config.yaml', help='Config file')
+
     # Desktop: the application's pages in a native window (UI-4)
     desktop_parser = subparsers.add_parser('desktop', help="Open the application's pages in a desktop window")
     desktop_parser.add_argument('path', nargs='?', default='/', help='Page to open (default: /)')
@@ -419,6 +424,10 @@ Examples:
         from quantum.runtime.ui_console import run_console
         sys.exit(run_console(args.config, args.path))
 
+    elif args.command == 'check':
+        from quantum.cli.check import run_check
+        sys.exit(run_check(args.config))
+
     elif args.command == 'desktop':
         from quantum.runtime.ui_desktop import run_desktop
         sys.exit(run_desktop(args.config, args.path, width=args.width, height=args.height))

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/core/features/ui_engine/src/parser.py

@@ -137,9 +137,24 @@ class UIParser:
             import difflib
             parecidas = difflib.get_close_matches(local_name, self.UI_TAG_MAP, n=1)
             dica = f"; did you mean <ui:{parecidas[0]}>?" if parecidas else ""
-            raise UIParseError(f"Unknown UI tag: <ui:{local_name}>{dica}")
+            erro = UIParseError(f"Unknown UI tag: <ui:{local_name}>{dica}")
+            erro.line = getattr(element, 'sourceline', None)
+            raise erro
         method = getattr(self, method_name)
-        return method(element)
+        try:
+            node = method(element)
+        except UIParseError as exc:
+            if getattr(exc, 'line', None) is None:
+                exc.line = getattr(element, 'sourceline', None)
+            raise
+        # DEV-2: a ui:* element knows its line and file, like a q: statement.
+        if getattr(element, 'sourceline', None) and node is not None:
+            try:
+                node.source_line = element.sourceline
+                node.source_file = getattr(self.parent, '_source_path', None)
+            except AttributeError:
+                pass
+        return node
 
     # ------------------------------------------------------------------
     # Helpers

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/core/parser.py

@@ -11,6 +11,7 @@ from typing import Union, Optional, List
 # Fix imports
 
 from quantum.core.html_compat import normalise_html
+from quantum.core.xml_lines import fromstring_with_lines, line_of
 from quantum.core.ast_nodes import (
     QuantumNode, ComponentNode, ApplicationNode, JobNode,
     QuantumParam, QuantumReturn, QuantumRoute,
@@ -222,6 +223,23 @@ def _explain_xml_error(error, source: str) -> str:
     return message
 
 
+def _at(erro: 'QuantumParseError', onde) -> 'QuantumParseError':
+    """The error belongs to this node's (or element's) line."""
+    erro.line = line_of(onde)
+    return erro
+
+
+def _with_line(erro: 'QuantumParseError', source: str, line: Optional[int] = None) -> 'QuantumParseError':
+    """DEV-2: a parse error says where it is — `at line N: <the line>`."""
+    line = line or getattr(erro, 'line', None)
+    erro.line = line
+    if line and ' at line ' not in str(erro):
+        linhas = source.splitlines()
+        trecho = linhas[line - 1].strip() if 0 < line <= len(linhas) else ''
+        erro.args = (f"{erro}\n  at line {line}: {trecho}" if trecho else f"{erro} (line {line})",)
+    return erro
+
+
 class QuantumParser:
     """Main parser for .q files"""
 
@@ -370,17 +388,19 @@ class QuantumParser:
             # parse for exactly those two reasons and returned HTTP 400.
             content = normalise_html(source)
             content = self._inject_namespace(content)
-            root = ET.fromstring(content)
+            root = fromstring_with_lines(content)
             self._nest_else_siblings(root)
             return self._parse_root_element(root, Path("<string>"))
         except ET.ParseError as e:
-            raise QuantumParseError(_explain_xml_error(e, source))
-        except QuantumParseError:
-            raise
+            erro = QuantumParseError(_explain_xml_error(e, source))
+            erro.line = getattr(e, 'position', (None, None))[0]
+            raise erro
+        except QuantumParseError as e:
+            raise _with_line(e, source)
         except ParserError as e:
             # A tag parser's own error is a parse error with a message meant
             # for the author, not an "Unexpected error".
-            raise QuantumParseError(str(e)) from e
+            raise _with_line(QuantumParseError(str(e)), source, getattr(e, 'line', None)) from e
         except Exception as e:
             raise QuantumParseError(f"Unexpected error: {e}")
 
@@ -412,7 +432,9 @@ class QuantumParser:
             self._source_path = str(path.resolve())
             source = Path(file_path).read_text(encoding="utf-8")
             return self.parse(source)
-        except QuantumParseError:
+        except QuantumParseError as e:
+            if getattr(e, 'file', None) is None:
+                e.file = str(path.resolve())                  # DEV-2
             raise
         except ParserError as e:
             # A tag parser's own error is a parse error with a message meant
@@ -498,7 +520,7 @@ class QuantumParser:
         conhecidas |= {'return', 'else', 'elseif'}
         parecidas = difflib.get_close_matches(name, sorted(conhecidas), n=3, cutoff=0.6)
         dica = (" Did you mean " + " or ".join(f"<q:{p}>" for p in parecidas) + "?") if parecidas else ""
-        return f"<q:{name}> is not a Quantum tag.{dica}"
+        return f"<q:{name}> is not a Quantum tag (PARSE-1).{dica}"
 
     @staticmethod
     def _is_quantum_tag(element: ET.Element) -> bool:
@@ -683,12 +705,12 @@ class QuantumParser:
                 lidos = names_read(re.sub(r'\{([^{}]*)\}', r'\1', condicao)) & definidos
                 if lidos:
                     nome = sorted(lidos)[0]
-                    raise QuantumParseError(
+                    raise _at(QuantumParseError(
                         f'<q:if condition="{condicao}"> in <q:component name="{component.name}"> '
-                        f'redirects, so it also runs before the page\'s q:action — where the page '
+                        f'redirects (AUTH-6), so it also runs before the page\'s q:action — where the page '
                         f'has not run and {{{nome}}} does not exist, and the guard would let the '
                         f'action through. Read the scope directly (e.g. session.x), or protect the '
-                        f'page with require_auth / require_role. See {HOW_A_PAGE_RUNS}')
+                        f'page with require_auth / require_role. See {HOW_A_PAGE_RUNS}'), guarda)
 
     # Nodes the HTML renderer draws. Anything else inside markup is a statement,
     # and statements run in the execution pass, before the render pass sees
@@ -762,21 +784,21 @@ class QuantumParser:
             for node in nodes:
                 if not isinstance(node, self._RENDERED) and not is_ui_node(node):
                     if onde and onde[0] == 'markup':
-                        raise QuantumParseError(
+                        raise _at(QuantumParseError(
                             f'{tag(node)} inside {onde[1]} in <q:component name="{component.name}"> '
-                            f'never runs: statements run before the page is rendered, and markup '
+                            f'never runs (PARSE-2): statements run before the page is rendered, and markup '
                             f'is only rendered. Move it above the markup (or into a q:action). '
-                            f'See {HOW_A_PAGE_RUNS}')
+                            f'See {HOW_A_PAGE_RUNS}'), node)
                     nome = getattr(node, 'name', None)
                     # A running total read AFTER the loop is fine; a value the
                     # loop's own rows read is not.
                     if onde and isinstance(nome, str) and usado(nome, onde[1]):
-                        raise QuantumParseError(
+                        raise _at(QuantumParseError(
                             f'{tag(node)} inside a q:loop whose rows use {{{nome}}} in '
                             f'<q:component name="{component.name}">: the loop runs for every item '
-                            f'before any row is rendered, so every row would show the last value. '
+                            f'before any row is rendered, so every row would show the last value (PARSE-2). '
                             f'Compute it in the expression instead, e.g. {{item.price * item.qty}}. '
-                            f'See {HOW_A_PAGE_RUNS}')
+                            f'See {HOW_A_PAGE_RUNS}'), node)
                     continue
                 if isinstance(node, HTMLNode):
                     andar(filhos(node), onde if onde and onde[0] == 'markup' else ('markup', f'<{node.tag}>'))
@@ -844,6 +866,27 @@ class QuantumParser:
                 if_node.add_else_statement(stmt)
 
     def _parse_statement(self, element: ET.Element) -> Optional[QuantumNode]:
+        """Parse one statement, and remember where it is in the file (DEV-2).
+
+        The node gets `source_line`, which runtime errors report; a parse
+        error from this element — or from inside it, if nothing deeper
+        claimed it — gets `line`.
+        """
+        try:
+            node = self._parse_statement_node(element)
+        except (QuantumParseError, ParserError) as exc:
+            if getattr(exc, 'line', None) is None:
+                exc.line = getattr(element, 'sourceline', None)
+            raise
+        if node is not None and getattr(element, 'sourceline', None):
+            try:
+                node.source_line = element.sourceline
+                node.source_file = self._source_path
+            except AttributeError:
+                pass                                  # a node with __slots__
+        return node
+
+    def _parse_statement_node(self, element: ET.Element) -> Optional[QuantumNode]:
         """Parse individual statement (return, set, dispatchEvent, etc)"""
         element_type = self._get_element_name(element)
 
@@ -857,7 +900,9 @@ class QuantumParser:
                 try:
                     return UIParser(self, page_mode=True).parse_ui_element(element_type, element)
                 except UIParseError as exc:
-                    raise QuantumParseError(str(exc)) from exc
+                    erro = QuantumParseError(str(exc))
+                    erro.line = getattr(exc, 'line', None)          # the inner ui:* element's line
+                    raise erro from exc
 
             # PARSE-1: <q:html>, <q:div> — an HTML element name in the q:
             # namespace. The registry answered for it with the HTML parser, so

quantum_framework-0.17.0/quantum/core/xml_lines.py

@@ -0,0 +1,81 @@
+"""XML into an ElementTree whose elements know their line (M2, DEV-2).
+
+`xml.etree` does not keep source positions, so an error found after parsing —
+a statement inside markup, an unknown attribute, a failing expression — could
+name the tag but not where it is. This builds the same tree with expat (the
+parser ElementTree itself runs on) and sets `element.sourceline` on each
+element.
+"""
+
+from xml.etree import ElementTree as ET
+from xml.parsers import expat
+
+
+class _Element(ET.Element):
+    """An Element that can carry `sourceline` (the C Element takes no new attributes)."""
+    sourceline = None
+
+
+def fromstring_with_lines(text: str) -> ET.Element:
+    """Like ET.fromstring(text); every element gets `sourceline` (1-based)."""
+    builder = ET.TreeBuilder(element_factory=_Element)
+    parser = expat.ParserCreate(None, '}')
+    parser.buffer_text = True
+    parser.ordered_attributes = True
+
+    def nome(bruto: str) -> str:
+        # expat with a separator reports "uri}local"; ElementTree spells it "{uri}local".
+        return '{' + bruto if '}' in bruto else bruto
+
+    def inicio(tag, atributos):
+        pares = dict(zip(atributos[0::2], atributos[1::2]))
+        elemento = builder.start(nome(tag), {nome(k): v for k, v in pares.items()})
+        elemento.sourceline = parser.CurrentLineNumber
+
+    parser.StartElementHandler = inicio
+    parser.EndElementHandler = lambda tag: builder.end(nome(tag))
+    parser.CharacterDataHandler = builder.data
+    try:
+        parser.Parse(text, True)
+    except expat.ExpatError as exc:
+        erro = ET.ParseError(str(exc))
+        erro.code = exc.code
+        erro.position = (exc.lineno, exc.offset)
+        raise erro from None
+    return builder.close()
+
+
+def line_of(item) -> int:
+    """The source line of an element or an AST node, or None."""
+    return getattr(item, 'sourceline', None) or getattr(item, 'source_line', None)
+
+
+def tag_error(exc: BaseException, node) -> None:
+    """DEV-2: the innermost node an error passes through names its file and line.
+
+    Innermost across wrapping too: an error in a called component is re-raised
+    as a new exception by the page; the line inside the component, already in
+    the chain, wins over the line of the call."""
+    if error_location(exc)[1] is not None:
+        return
+    linha = getattr(node, 'source_line', None)
+    if not linha:
+        return
+    try:
+        exc.quantum_line = linha
+        exc.quantum_file = getattr(node, 'source_file', None)
+    except (AttributeError, TypeError):
+        pass                                    # an exception type with __slots__
+
+
+def error_location(exc: BaseException):
+    """(file, line) of an error or of any error it wraps; (None, None) if unknown."""
+    visto = set()
+    while exc is not None and id(exc) not in visto:
+        visto.add(id(exc))
+        if getattr(exc, 'quantum_line', None) is not None:
+            return getattr(exc, 'quantum_file', None), exc.quantum_line
+        if getattr(exc, 'line', None) is not None and type(exc).__name__ == 'QuantumParseError':
+            return getattr(exc, 'file', None), exc.line
+        exc = exc.__cause__ or exc.__context__
+    return None, None

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/runtime/action_handler.py

@@ -107,7 +107,12 @@ class ActionHandler:
                 context.set_variable(key, value)
 
             # 4. Execute action body
-            redirect_info = self._execute_action_body(action, context)
+            try:
+                redirect_info = self._execute_action_body(action, context)
+            finally:
+                # M12: the /_dev panel shows the action's variables (no-op off debug).
+                from quantum.runtime.dev_panel import note_scopes
+                note_scopes(context, 'action')
 
             # 5. Sync session mutations back to Flask (mirrors web_server.py's
             # render path, which does the same after execute_component()).
@@ -144,7 +149,7 @@ class ActionHandler:
             mensagem = str(e)
             if 'is not defined' in mensagem:
                 from quantum.core.docs_links import HOW_A_PAGE_RUNS
-                mensagem += (". A q:action does not run the page's statements: "
+                mensagem += (". A q:action does not run the page's statements (ACT-9): "
                              f"query or compute what it needs inside the action. See {HOW_A_PAGE_RUNS}")
             logger.exception(
                 "q:action %r failed: %s", getattr(action, 'name', '?'), mensagem

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/runtime/component.py

@@ -284,7 +284,7 @@ class ComponentRuntime:
             return None
 
         except Exception as e:
-            raise ComponentExecutionError(f"Execution error: {e}")
+            raise ComponentExecutionError(f"Execution error: {e}") from e
 
     def _enter(self, component: ComponentNode, params: Dict[str, Any]) -> None:
         """Make `component` current: its functions, and the scopes passed in params."""

{quantum_framework-0.16.0 → quantum_framework-0.17.0}/quantum/runtime/database_service.py

@@ -7,11 +7,13 @@ import time
 from pathlib import Path
 from typing import Dict, Any, List, Optional
 from dataclasses import dataclass, asdict
+from quantum.runtime.dev_panel import note_query
 
 logger = logging.getLogger('quantum.database')
 
 
 @dataclass
+
 class QueryResult:
     """Container for query results and metadata"""
     data: List[Dict[str, Any]]
@@ -346,6 +348,8 @@ class DatabaseService:
 
             # Calculate execution time
             execution_time = (time.time() - start_time) * 1000  # Convert to ms
+            # M12: the /_dev panel shows each query of the request (no-op off debug).
+            note_query(datasource_name, sql, params, execution_time, record_count)
 
             return QueryResult(
                 data=data,
@@ -369,6 +373,7 @@ class DatabaseService:
                     # a failed rollback on a broken connection must not
                     # replace it. Deliberately silent.
                     pass
+            note_query(datasource_name, sql, params, (time.time() - start_time) * 1000, None, error=str(e))
             raise QueryExecutionError(f"Query execution failed: {e}")
 
     def _prepare_query(self, sql: str, params: Dict[str, Any], db_type: str) -> tuple: