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

{quantum_framework-0.17.0 → quantum_framework-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quantum-framework
-Version: 0.17.0
+Version: 0.19.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.17.0 → quantum_framework-0.19.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quantum-framework"
-version = "0.17.0"
+version = "0.19.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_framework-0.19.0}/quantum/cli/check.py

@@ -102,9 +102,30 @@ class ProjectChecker:
         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
+        from quantum.core.ast_nodes import ActionNode, QueryNode
+        from quantum.runtime.db_schema import check_sql, read_schema
         for filho in _children(node):
+            if isinstance(filho, ActionNode) and getattr(filho, 'table', None):
+                # UI-10: the table the action takes its params from exists, with those columns.
+                ds = filho.table_datasource
+                if ds not in self.datasources:
+                    self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                 f'<q:action name="{filho.name}">: datasource {ds!r} is not '
+                                                 f'declared in quantum.config.yaml'))
+                elif self._connection(ds) is not None:
+                    esquema = read_schema(self._connection(ds))
+                    tabela = esquema.get(filho.table)
+                    if tabela is None:
+                        self.problems.append(Problem(rel, getattr(filho, 'source_line', None),
+                                                     f'<q:action name="{filho.name}" table="{filho.table}">: '
+                                                     f'no such table (tables: {", ".join(esquema) or "none"})'))
+                    else:
+                        for coluna in filho.table_columns or []:
+                            if coluna not in tabela.columns:
+                                self.problems.append(Problem(
+                                    rel, getattr(filho, 'source_line', None),
+                                    f'<q:action name="{filho.name}" columns=...>: table "{filho.table}" '
+                                    f'has no column "{coluna}"'))
             if isinstance(filho, QueryNode):
                 ds = filho.datasource
                 if not ds or ds.startswith('knowledge:') or getattr(filho, 'source', None):

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

@@ -399,6 +399,15 @@ Examples:
     migrate_create_parser = migrate_subparsers.add_parser('create', help='Create a new migration')
     migrate_create_parser.add_argument('name', help='Migration name')
 
+    # M6 (DB-10): schema.sql as the source of truth
+    migrate_plan_parser = migrate_subparsers.add_parser(
+        'plan', help='Compare schema.sql with the migrations and plan the migration')
+    migrate_plan_parser.add_argument('--schema', default='schema.sql', help='Schema file (default: schema.sql)')
+    migrate_plan_parser.add_argument('--write', metavar='NAME', help='Save the plan as migration V00N_NAME')
+    migrate_plan_parser.add_argument('--yes', action='store_true', help='Do not ask before writing')
+    migrate_plan_parser.add_argument('--allow-data-loss', action='store_true',
+                                     help='Write a plan that drops tables or columns')
+
     # Parse arguments
     args = parser.parse_args()
 
@@ -541,13 +550,18 @@ Examples:
                 if failed:
                     sys.exit(1)
 
+            elif args.migrate_command == 'plan':
+                from quantum.cli.schema_plan import run_plan
+                sys.exit(run_plan(Path.cwd(), args.schema, args.write, args.yes, args.allow_data_loss,
+                                  interactive=sys.stdin.isatty()))
+
             elif args.migrate_command == 'create':
                 filepath = runner.create(args.name)
                 print(f"Created migration: {filepath}")
                 print(f"Also created rollback: {filepath.with_suffix('.down.sql')}")
 
             else:
-                print("Usage: quantum migrate <status|up|down|create> [options]")
+                print("Usage: quantum migrate <status|up|down|create|plan> [options]")
                 sys.exit(1)
 
             sys.exit(0)

quantum_framework-0.19.0/quantum/cli/schema_plan.py

@@ -0,0 +1,273 @@
+"""`quantum migrate plan`: a declarative schema (M6, DB-10).
+
+You edit `schema.sql` — the tables as they should be. `quantum migrate plan`
+compares it with the schema the migrations produce, shows what changes, marks
+what loses data, and `--write` saves the migration (and its rollback) after
+confirmation. `quantum migrate up` applies it as any other.
+
+Both sides are built in in-memory SQLite databases — the migrations applied in
+order, and schema.sql — and compared with the schema reader of `quantum check`
+(quantum/runtime/db_schema.py). The development database is not read: the
+plan is the same on any machine and in CI.
+
+SQLite can add a column but not change one, so any other change to a table
+rebuilds it: create the new table, copy the columns both have, drop the old,
+rename. Before a plan is written it is checked: applied to the migrations'
+schema it must produce exactly schema.sql's.
+"""
+
+import re
+import sqlite3
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from quantum.runtime.db_schema import Column, read_schema
+
+# Tables that belong to Quantum, not to the app's schema.
+INTERNAL_TABLES = {'_migrations', 'quantum_history'}
+
+
+class SchemaPlanError(Exception):
+    """The plan cannot be made (no schema.sql, invalid SQL, a change it cannot express)."""
+
+
+@dataclass
+class Step:
+    kind: str                 # add-table, drop-table, add-column, rebuild, add-index, drop-index
+    target: str               # "posts" or "posts.summary"
+    detail: str = ''
+    sql: List[str] = field(default_factory=list)
+    loses_data: bool = False
+    warning: str = ''
+
+    def line(self) -> str:
+        mark = {'add-table': '+', 'add-column': '+', 'add-index': '+', 'drop-table': '-',
+                'drop-index': '-', 'rebuild': '~'}.get(self.kind, '?')
+        text = f'{mark} {self.kind.replace("-", " ")} {self.target}'
+        if self.detail:
+            text += f' ({self.detail})'
+        if self.loses_data:
+            text += '  !! loses data'
+        if self.warning:
+            text += f'  !! {self.warning}'
+        return text
+
+
+def _database(scripts: List[Tuple[str, str]]) -> sqlite3.Connection:
+    conn = sqlite3.connect(':memory:')
+    for origin, sql in scripts:
+        try:
+            conn.executescript(sql)
+        except sqlite3.Error as exc:
+            raise SchemaPlanError(f'{origin}: {exc}') from exc
+    return conn
+
+
+def _migration_scripts(migrations_dir: Path) -> List[Tuple[str, str]]:
+    if not migrations_dir.exists():
+        return []
+    files = [f for f in sorted(migrations_dir.glob('*.sql')) if not f.name.endswith('.down.sql')]
+    return [(f.name, f.read_text(encoding='utf-8')) for f in files if '_' in f.stem]
+
+
+def _tables(conn) -> Dict[str, object]:
+    return {name: t for name, t in read_schema(conn).items() if name not in INTERNAL_TABLES}
+
+
+def _create_sql(conn, table: str) -> str:
+    return conn.execute("SELECT sql FROM sqlite_master WHERE type = 'table' AND name = ?",
+                        (table,)).fetchone()[0]
+
+
+def _indexes(conn) -> Dict[str, Tuple[str, str]]:
+    """Explicit indexes: name -> (table, sql)."""
+    return {name: (table, sql) for name, table, sql in conn.execute(
+        "SELECT name, tbl_name, sql FROM sqlite_master WHERE type = 'index' AND sql IS NOT NULL")
+        if table not in INTERNAL_TABLES}
+
+
+def _column_sql(column: Column) -> str:
+    parts = [f'"{column.name}"']
+    if column.type:
+        parts.append(column.type)
+    if column.not_null:
+        parts.append('NOT NULL')
+    if column.default is not None:
+        parts.append(f'DEFAULT {column.default}')
+    if column.options:
+        options = ', '.join("'" + o.replace("'", "''") + "'" for o in column.options)
+        parts.append(f'CHECK ("{column.name}" IN ({options}))')
+    if column.references:
+        parts.append(f'REFERENCES "{column.references[0]}"("{column.references[1]}")')
+    return ' '.join(parts)
+
+
+def _differences(a: Column, b: Column) -> List[str]:
+    changed = []
+    for label, x, y in (('type', (a.type or '').upper(), (b.type or '').upper()),
+                        ('NOT NULL', a.not_null, b.not_null), ('default', a.default, b.default),
+                        ('primary key', a.primary_key, b.primary_key), ('CHECK', a.options, b.options),
+                        ('references', a.references, b.references)):
+        if x != y:
+            changed.append(label)
+    return changed
+
+
+def diff(current_db, desired_db) -> List[Step]:
+    """The steps that turn the first database's schema into the second's."""
+    current, desired = _tables(current_db), _tables(desired_db)
+    steps: List[Step] = []
+    rebuilt = set()
+
+    for name in sorted(set(desired) - set(current)):
+        steps.append(Step('add-table', name, sql=[_create_sql(desired_db, name) + ';']))
+
+    for name in sorted(set(current) & set(desired)):
+        before, after = current[name].columns, desired[name].columns
+        added = [c for c in after if c not in before]
+        removed = [c for c in before if c not in after]
+        changed = {c: _differences(before[c], after[c]) for c in before
+                   if c in after and _differences(before[c], after[c])}
+        addable = all(not after[c].primary_key and (not after[c].not_null or after[c].default is not None)
+                      for c in added)
+        if not removed and not changed and addable:
+            for c in added:
+                steps.append(Step('add-column', f'{name}.{c}', after[c].type or '',
+                                  [f'ALTER TABLE "{name}" ADD COLUMN {_column_sql(after[c])};']))
+            continue
+        if not (added or removed or changed):
+            continue
+        common = ', '.join(f'"{c}"' for c in after if c in before)
+        create = re.sub(r'^\s*CREATE\s+TABLE\s+("?)' + re.escape(name) + r'\1',
+                        f'CREATE TABLE "{name}__new"', _create_sql(desired_db, name), count=1, flags=re.I)
+        details = [f'+ {c}' for c in added] + [f'- {c}' for c in removed] + \
+                  [f'{c}: {", ".join(d)}' for c, d in changed.items()]
+        warning = ''
+        if any('NOT NULL' in d and after[c].not_null for c, d in changed.items()) or \
+                any(after[c].not_null and after[c].default is None for c in added):
+            warning = 'fails if existing rows have no value for a NOT NULL column'
+        steps.append(Step('rebuild', name, '; '.join(details), [
+            create + ';',
+            f'INSERT INTO "{name}__new" ({common}) SELECT {common} FROM "{name}";',
+            f'DROP TABLE "{name}";',
+            f'ALTER TABLE "{name}__new" RENAME TO "{name}";',
+        ], loses_data=bool(removed) or any('type' in d for d in changed.values()), warning=warning))
+        rebuilt.add(name)
+
+    for name in sorted(set(current) - set(desired)):
+        steps.append(Step('drop-table', name, sql=[f'DROP TABLE "{name}";'], loses_data=True))
+
+    # Indexes: a rebuilt table lost its own, so they are created again.
+    before_idx, after_idx = _indexes(current_db), _indexes(desired_db)
+    for name, (table, sql) in sorted(before_idx.items()):
+        if table in desired and table not in rebuilt and after_idx.get(name, (None, None))[1] != sql:
+            steps.append(Step('drop-index', name, sql=[f'DROP INDEX "{name}";']))
+    for name, (table, sql) in sorted(after_idx.items()):
+        if before_idx.get(name, (None, None))[1] != sql or table in rebuilt:
+            steps.append(Step('add-index', name, sql=[sql + ';']))
+    return steps
+
+
+def _schema_only(conn) -> str:
+    """The CREATE statements of a database, tables before indexes, without its rows."""
+    rows = conn.execute("SELECT type, sql FROM sqlite_master WHERE sql IS NOT NULL "
+                        "AND name NOT LIKE 'sqlite_%' ORDER BY type = 'index', rowid").fetchall()
+    return '\n'.join(sql + ';' for _type, sql in rows)
+
+
+def _signature(conn) -> tuple:
+    tables = _tables(conn)
+    return (tuple(sorted((n, tuple(sorted((c.name, (c.type or '').upper(), c.not_null, c.default, c.primary_key,
+                                              tuple(c.options or ()), c.references)
+                                             for c in t.columns.values()))) for n, t in tables.items())),
+            tuple(sorted((n, s) for n, (_t, s) in _indexes(conn).items())))
+
+
+@dataclass
+class Plan:
+    steps: List[Step]
+    up_sql: str
+    down_sql: str
+
+    @property
+    def loses_data(self) -> bool:
+        return any(s.loses_data for s in self.steps)
+
+
+def make_plan(schema_file: Path, migrations_dir: Path) -> Plan:
+    if not schema_file.exists():
+        raise SchemaPlanError(f'{schema_file} does not exist: write the tables as they should be, '
+                              f'e.g. CREATE TABLE posts (id INTEGER PRIMARY KEY, title TEXT NOT NULL);')
+    migrations = _migration_scripts(migrations_dir)
+    current = _database(migrations)
+    desired = _database([(schema_file.name, schema_file.read_text(encoding='utf-8'))])
+    steps = diff(current, desired)
+    up = '\n'.join(s for step in steps for s in step.sql)
+    down = '\n'.join(s for step in diff(desired, current) for s in step.sql)
+    if steps:
+        # The plan must do what it says: applied, it yields schema.sql's schema.
+        # Checked on the structure only — what existing rows may break is the
+        # step's warning, shown in the plan, not a reason to hide the plan.
+        check = _database([('migrations (schema only)', _schema_only(current)), ('plan', up)])
+        if _signature(check) != _signature(desired):
+            raise SchemaPlanError('the generated migration does not reproduce schema.sql — '
+                                  'write this change as a migration by hand (quantum migrate create)')
+    return Plan(steps, up, down)
+
+
+def next_version(migrations_dir: Path) -> str:
+    numbers = [int(m.group(1)) for f in migrations_dir.glob('V*.sql')
+               for m in [re.match(r'V(\d+)_', f.name)] if m]
+    return f'V{(max(numbers) + 1 if numbers else 1):03d}'
+
+
+def write_plan(plan: Plan, migrations_dir: Path, name: str) -> Path:
+    migrations_dir.mkdir(parents=True, exist_ok=True)
+    slug = re.sub(r'[^a-z0-9_]+', '_', name.lower()).strip('_') or 'schema'
+    version = next_version(migrations_dir)
+    path = migrations_dir / f'{version}_{slug}.sql'
+    header = '-- Generated by `quantum migrate plan` from schema.sql (DB-10)\n'
+    summary = '\n'.join(f'-- {s.line()}' for s in plan.steps)
+    path.write_text(f'{header}{summary}\n\n{plan.up_sql}\n', encoding='utf-8')
+    (migrations_dir / f'{version}_{slug}.down.sql').write_text(
+        f'{header}-- rollback\n\n{plan.down_sql}\n', encoding='utf-8')
+    return path
+
+
+def run_plan(project: Path, schema: Optional[str], write: Optional[str], yes: bool,
+             allow_data_loss: bool, ask=input, interactive: bool = True) -> int:
+    """The `quantum migrate plan` command. Returns the exit code."""
+    from quantum.cli.commands.migrate import _paths_migrations
+    migrations_dir = project / _paths_migrations(project)
+    schema_file = project / (schema or 'schema.sql')
+    try:
+        plan = make_plan(schema_file, migrations_dir)
+    except SchemaPlanError as exc:
+        print(f'[ERROR] {exc}')
+        return 1
+    if not plan.steps:
+        print(f'Nothing to do: the migrations already produce {schema_file.name}.')
+        return 0
+    print(f'Plan: {schema_file.name} vs. the migrations in {migrations_dir.name}/\n')
+    for step in plan.steps:
+        print('  ' + step.line())
+    print('\nSQL:\n' + plan.up_sql)
+    if not write:
+        print('\nNothing written. `quantum migrate plan --write <name>` saves it as a migration.')
+        return 0
+    if plan.loses_data and not allow_data_loss:
+        print('\n[REFUSED] This plan loses data (marked !!). Check it, then run again with '
+              '--allow-data-loss.')
+        return 1
+    if not yes:
+        if not interactive:
+            print('\n[REFUSED] Confirm with --yes (not a terminal: nobody to ask).')
+            return 1
+        answer = ask(f'\nWrite migration {next_version(migrations_dir)}_{write}? [y/N] ').strip().lower()
+        if answer not in ('y', 'yes'):
+            print('Nothing written.')
+            return 1
+    path = write_plan(plan, migrations_dir, write)
+    print(f'Written: {path} (and {path.stem}.down.sql). Apply with `quantum migrate up`.')
+    return 0

{quantum_framework-0.17.0 → quantum_framework-0.19.0}/quantum/core/ast_nodes.py

@@ -698,6 +698,8 @@ class QueryNode(QuantumNode):
         self.interval = None
         self.paginate = False  # Enable automatic pagination
         self.page = None
+        self.page_expr = None  # DB-9: page as an expression (default {query.page})
+        self.sortable = False  # UI-13: ORDER BY the URL's ?sort=/&dir=
         self.page_size = 20
         self.timeout = None
         self.maxrows = None
@@ -1137,6 +1139,10 @@ class ActionNode(QuantumNode):
         self.method = method.upper()
         self.params: List[QuantumParam] = []
         self.body: List[QuantumNode] = []
+        # UI-10 (M17): params from a table's schema — see quantum/runtime/table_params.py
+        self.table: Optional[str] = None
+        self.table_datasource: Optional[str] = None
+        self.table_columns: Optional[List[str]] = None
 
         # Action configuration
         self.validate_csrf = True  # Auto CSRF protection

{quantum_framework-0.17.0 → quantum_framework-0.19.0}/quantum/core/features/ui_engine/src/ast_nodes.py

@@ -319,6 +319,9 @@ class UIFormNode(QuantumNode, UILayoutMixin):
 
     def __init__(self):
         self.on_submit: Optional[str] = None
+        self.rules: Optional[str] = None  # UI-9: 'off' = no rules from the action
+        self.values: Optional[str] = None  # UI-10: {row} whose fields fill the form
+        self.submit: Optional[str] = None  # UI-10: text of the generated button
         self.children: List[QuantumNode] = []
 
         # Validation mode: 'client', 'server', or 'both' (default)
@@ -550,6 +553,8 @@ class UIInputNode(QuantumNode, UILayoutMixin):
     def __init__(self):
         self.bind: Optional[str] = None
         self.value: Optional[str] = None  # initial value (UI-6)
+        self.search: Optional[str] = None  # UI-12: id of the region it refreshes as you type
+        self.delay: Optional[int] = None   # UI-12: ms after the last key (300 with search=)
         self.placeholder: Optional[str] = None
         self.input_type: str = "text"    # text, password, email, number
         self.on_change: Optional[str] = None
@@ -673,6 +678,9 @@ class UITableNode(QuantumNode, UILayoutMixin):
     def __init__(self):
         self.source: Optional[str] = None
         self.as_var: Optional[str] = None  # row variable for column content (UI-5)
+        self.sort: bool = False               # UI-13: headers sort the query
+        self.edit: Optional[str] = None       # UI-13: table whose cells are edited in place
+        self.edit_datasource: Optional[str] = None
         self.children: List[QuantumNode] = []  # UIColumnNode children
         self._init_layout_attrs()
 
@@ -697,6 +705,7 @@ class UIColumnNode(QuantumNode):
         self.label: Optional[str] = None
         self.column_width: Optional[str] = None
         self.align: Optional[str] = None  # left, center, right
+        self.edit: bool = True            # UI-13: edit="false" keeps it read-only
         # UI-5: a column with content draws it once per row (buttons, links).
         self.children: List[QuantumNode] = []
 
@@ -1870,6 +1879,41 @@ class UIDatePickerNode(QuantumNode, UILayoutMixin):
         return self._validate_layout()
 
 
+class UIPagerNode(QuantumNode, UILayoutMixin):
+    """<ui:pager for="query"> — previous, page numbers and next over a paginated query (UI-11)."""
+
+    def __init__(self):
+        self.for_query: Optional[str] = None
+        self.param: str = 'page'
+        self.window: int = 2
+        self.children: List[QuantumNode] = []
+        self._init_layout_attrs()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "ui_pager", "for": self.for_query, "param": self.param}
+
+    def validate(self) -> List[str]:
+        return [] if self.for_query else ["ui:pager needs for="]
+
+
+class UIHistoryNode(QuantumNode, UILayoutMixin):
+    """<ui:history table="t" key="{row.id}" datasource="db"> — a row's change history (DB-11)."""
+
+    def __init__(self):
+        self.table: Optional[str] = None
+        self.key: Optional[str] = None
+        self.datasource: Optional[str] = None
+        self.limit: int = 50
+        self.children: List[QuantumNode] = []
+        self._init_layout_attrs()
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {"type": "ui_history", "table": self.table, "key": self.key}
+
+    def validate(self) -> List[str]:
+        return []
+
+
 def is_ui_node(node) -> bool:
     """A ui:* element (UI-1): markup, drawn by a renderer, never executed."""
     return type(node).__module__ == __name__
@@ -1882,6 +1926,6 @@ CORE_TAGS = frozenset({
     'window', 'hbox', 'vbox', 'grid', 'panel', 'section', 'scrollbox', 'spacer', 'rule',
     'header', 'footer', 'card', 'card-header', 'card-body', 'card-footer', 'tabpanel', 'tab',
     'text', 'badge', 'alert', 'link', 'image', 'progress',
-    'table', 'column', 'list', 'item',
+    'table', 'column', 'list', 'item', 'pager', 'history',
     'form', 'formitem', 'input', 'checkbox', 'switch', 'radio', 'select', 'option', 'button',
 })

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

@@ -28,7 +28,7 @@ from .ast_nodes import (
     UIToastNode, UIToastContainerNode,
     UICarouselNode, UISlideNode,
     UIStepperNode, UIStepNode,
-    UICalendarNode, UIDatePickerNode,
+    UICalendarNode, UIDatePickerNode, UIPagerNode, UIHistoryNode,
 )
 from quantum.core.features.theming.src import UIThemeNode, UIColorNode
 from quantum.core.ast_nodes import TextNode
@@ -81,6 +81,8 @@ class UIParser:
         'select': '_parse_ui_select',
         'table': '_parse_ui_table',
         'column': '_parse_ui_column',
+        'pager': '_parse_ui_pager',
+        'history': '_parse_ui_history',
         'list': '_parse_ui_list',
         'item': '_parse_ui_item',
         'image': '_parse_ui_image',
@@ -359,6 +361,13 @@ class UIParser:
         node = UIFormNode()
         node.on_submit = element.get('on-submit')
         node.send = element.get('with')
+        # UI-9: rules="off" stops the form from taking its fields' rules from the action.
+        node.rules = element.get('rules')
+        # UI-10: an edit form opens with a row's values; the generated button's text.
+        node.values = element.get('values')
+        node.submit = element.get('submit')
+        if node.rules not in (None, 'on', 'off'):
+            raise UIParseError(f'<ui:form rules="{node.rules}">: use on (the default) or off')
 
         # Validation attributes
         node.validation_mode = element.get('validation', 'both')
@@ -430,6 +439,14 @@ class UIParser:
         node = UIInputNode()
         node.bind = element.get('bind')
         node.value = element.get('value')
+        # UI-12: search as you type — refresh the element with this id.
+        node.search = element.get('search')
+        espera = element.get('delay')
+        if espera is not None and not espera.isdigit():
+            raise UIParseError(f'<ui:input delay="{espera}">: milliseconds, e.g. delay="300"')
+        node.delay = int(espera) if espera is not None else (300 if node.search else None)
+        if node.search is not None and not node.bind:
+            raise UIParseError('<ui:input search=...> needs bind= (the URL parameter it sets)')
         node.placeholder = element.get('placeholder')
         node.input_type = element.get('type', 'text')
         node.on_change = element.get('on-change')
@@ -498,6 +515,14 @@ class UIParser:
         node = UITableNode()
         node.source = element.get('source')
         node.as_var = element.get('as')
+        # UI-13: sortable headers and cells edited in place.
+        node.sort = self._parse_bool(element.get('sort'))
+        node.edit = element.get('edit')
+        node.edit_datasource = element.get('datasource')
+        if node.edit and not node.edit_datasource:
+            raise UIParseError(f'<ui:table edit="{node.edit}"> needs datasource= (where the table is)')
+        if (node.sort or node.edit) and not node.source:
+            raise UIParseError('<ui:table sort/edit> needs source="{query}"')
         self._apply_layout_attrs(node, element)
         # Parse child <ui:column> elements
         self._parse_children(element, node)
@@ -509,9 +534,38 @@ class UIParser:
         node.label = element.get('label')
         node.column_width = element.get('width')
         node.align = element.get('align')
+        node.edit = element.get('edit', 'true') != 'false'
         self._parse_children(element, node)
         return node
 
+    def _parse_ui_pager(self, element: ET.Element) -> UIPagerNode:
+        node = UIPagerNode()
+        node.for_query = element.get('for')
+        if not node.for_query:
+            raise UIParseError('<ui:pager> needs for="<the paginated q:query>"')
+        node.param = element.get('param') or 'page'
+        janela = element.get('window')
+        if janela is not None and not janela.isdigit():
+            raise UIParseError(f'<ui:pager window="{janela}">: the number of pages shown each side of the current one')
+        node.window = int(janela) if janela is not None else 2
+        self._apply_layout_attrs(node, element)
+        return node
+
+    def _parse_ui_history(self, element: ET.Element) -> UIHistoryNode:
+        node = UIHistoryNode()
+        node.table = element.get('table')
+        node.key = element.get('key')
+        node.datasource = element.get('datasource')
+        missing = [a for a in ('table', 'key', 'datasource') if not element.get(a)]
+        if missing:
+            raise UIParseError(f'<ui:history> needs {", ".join(a + "=" for a in missing)}')
+        limit = element.get('limit')
+        if limit is not None and not limit.isdigit():
+            raise UIParseError(f'<ui:history limit="{limit}">: a number of entries')
+        node.limit = int(limit) if limit is not None else 50
+        self._apply_layout_attrs(node, element)
+        return node
+
     def _parse_ui_list(self, element: ET.Element) -> UIListNode:
         node = UIListNode()
         node.source = element.get('source')

{quantum_framework-0.17.0 → quantum_framework-0.19.0}/quantum/core/parsers/data/query_parser.py

@@ -77,7 +77,27 @@ class QueryParser(BaseTagParser):
         # Parse attributes
         query_node.source = source
         query_node.paginate = self.get_bool_attr(element, 'paginate', False)
-        query_node.page = self.get_int_attr(element, 'page', 0) or None
+        # UI-13: ordered by the URL's ?sort=/&dir= (a <ui:table sort="true"> writes them)
+        query_node.sortable = self.get_bool_attr(element, 'sortable', False)
+        # DB-9: page= is an expression, resolved when the query runs; it was
+        # read as an int at parse time, so page="{query.page}" was always
+        # page 1. With paginate="true" and no page=, the page is the URL's
+        # `page` parameter — the one <ui:pager> writes.
+        pagina = element.get('page')
+        query_node.page = None
+        query_node.page_expr = None
+        if pagina is not None:
+            if '{' in pagina:
+                query_node.page_expr = pagina
+            elif pagina.strip().isdigit():
+                query_node.page = int(pagina)
+            else:
+                from quantum.core.parser import QuantumParseError
+                raise QuantumParseError(
+                    f'<q:query name="{name}" page="{pagina}">: a page number or an expression, '
+                    f'e.g. page="{{query.pagina}}"')
+        elif query_node.paginate:
+            query_node.page_expr = '{query.page}'
         # Accept both spellings: the codebase convention is camelCase, but
         # snake_case reads naturally in XML and the examples used it —
         # the mismatch made page_size None and crashed pagination with

{quantum_framework-0.17.0 → quantum_framework-0.19.0}/quantum/core/parsers/forms/action_parser.py

@@ -48,6 +48,21 @@ class ActionParser(BaseTagParser):
                     f'<q:action name="{name}"> {attr}= is not supported: it was accepted '
                     f'and never enforced. {porque}')
 
+        # UI-10 (M17): the action's params come from a table's schema, read
+        # from the database when the action is used; a q:param written wins.
+        action_node.table = element.get('table')
+        action_node.table_datasource = element.get('datasource')
+        colunas = element.get('columns')
+        action_node.table_columns = [c.strip() for c in colunas.split(',') if c.strip()] if colunas else None
+        if (action_node.table_datasource or colunas) and not action_node.table:
+            from quantum.core.parser import QuantumParseError
+            raise QuantumParseError(
+                f'<q:action name="{name}"> datasource= and columns= describe table=, which is missing')
+        if action_node.table and not action_node.table_datasource:
+            from quantum.core.parser import QuantumParseError
+            raise QuantumParseError(
+                f'<q:action name="{name}" table="{action_node.table}"> needs datasource= (where the table is)')
+
         # Parse children (params, statements)
         for child in element:
             child_type = self._get_element_name(child)