queryview 0.0.2__py3-none-any.whl

queryview/queries.py

@@ -0,0 +1,159 @@
+"""Predefined query store: reusable SQL keyed by connection type within a
+workspace (names are unique per workspace). Reuses the SQLite engine owned by
+connect.py."""
+
+from __future__ import annotations
+
+from typing import Any, ClassVar
+
+from sqlalchemy import UniqueConstraint
+from sqlmodel import Field, SQLModel, select
+from sqlmodel.ext.asyncio.session import AsyncSession
+
+from .connect import _engine_for_db, _ensure_schema
+
+
+class PredefinedQuery(SQLModel, table=True):
+    __tablename__: ClassVar[str] = "predefined_queries"
+    __table_args__ = (UniqueConstraint("workspace_id", "type", "query_name", name="uq_predefined_ws_type_name"),)
+
+    id: int | None = Field(default=None, primary_key=True)
+    query_name: str = Field(index=True)
+    type: str = Field(index=True)
+    workspace_id: int  # owning workspace (workspaces.id); names unique per workspace
+    query: str
+    # Raw YAML (column_name -> {type, value}) controlling cell rendering; NULL =
+    # none. Never parsed here — interpreted client-side, matched to columns by name.
+    cell_view: str | None = Field(default=None)
+    # Raw JSON text (or NULL) for saved presentation, stored verbatim like
+    # cell_view: order_by is [{"name","dir"}], fields is ["col", ...].
+    order_by: str | None = Field(default=None)
+    fields: str | None = Field(default=None)
+
+
+def _row_dict(r: PredefinedQuery) -> dict[str, str | None]:
+    """The row shape every accessor here returns (order_by/fields stay the
+    stored JSON text)."""
+    return {
+        "query_name": r.query_name,
+        "query": r.query,
+        "cell_view": r.cell_view,
+        "order_by": r.order_by,
+        "fields": r.fields,
+    }
+
+
+async def list_predefined_queries(conn_type: str, workspace_id: int) -> list[dict[str, str | None]]:
+    """Saved queries for a connection type within one workspace, ordered by name."""
+    await _ensure_schema()
+    async with AsyncSession(_engine_for_db()) as s:
+        rows = (
+            await s.exec(
+                select(PredefinedQuery)
+                .where(
+                    PredefinedQuery.type == conn_type,
+                    PredefinedQuery.workspace_id == workspace_id,
+                )
+                .order_by(PredefinedQuery.query_name)
+            )
+        ).all()
+    return [_row_dict(r) for r in rows]
+
+
+async def list_all_predefined_queries(workspace_id: int) -> list[dict[str, str | None]]:
+    """Every saved query in one workspace regardless of connection type,
+    ordered by (type, name) — the row shape of list_predefined_queries plus
+    `type`. Used by the whole-workspace YAML export."""
+    await _ensure_schema()
+    async with AsyncSession(_engine_for_db()) as s:
+        rows = (
+            await s.exec(
+                select(PredefinedQuery)
+                .where(PredefinedQuery.workspace_id == workspace_id)
+                .order_by(PredefinedQuery.type, PredefinedQuery.query_name)
+            )
+        ).all()
+    return [{"type": r.type, **_row_dict(r)} for r in rows]
+
+
+async def get_predefined_query(conn_type: str, query_name: str, workspace_id: int) -> dict[str, str | None] | None:
+    """One saved query by (workspace, type, name) — the unique key — in the same
+    row shape as list_predefined_queries items, or None."""
+    await _ensure_schema()
+    async with AsyncSession(_engine_for_db()) as s:
+        row = (
+            await s.exec(
+                select(PredefinedQuery).where(
+                    PredefinedQuery.type == conn_type,
+                    PredefinedQuery.query_name == query_name,
+                    PredefinedQuery.workspace_id == workspace_id,
+                )
+            )
+        ).first()
+    return _row_dict(row) if row is not None else None
+
+
+async def list_predefined_queries_view(conn_type: str, workspace_id: int) -> list[dict]:
+    """Like list_predefined_queries but with order_by/fields parsed from their
+    stored JSON text into values (cell_view stays raw YAML). Shared by the HTTP
+    list endpoint and the MCP list_queries tool so both present the same shape."""
+    import json
+
+    rows = await list_predefined_queries(conn_type, workspace_id)
+    for r in rows:
+        ob, fl = r.get("order_by"), r.get("fields")
+        r["order_by"] = json.loads(ob) if ob else None
+        r["fields"] = json.loads(fl) if fl else None
+    return rows
+
+
+async def save_predefined_queries(rows: list[dict[str, Any]], *, workspace_id: int) -> None:
+    """Upsert many predefined queries — each a dict with string `type`,
+    `query_name`, `query` and optional `cell_view`/`order_by`/`fields` (JSON
+    text or None) — in one transaction, keyed by (workspace, type, query_name)."""
+    await _ensure_schema()
+    async with AsyncSession(_engine_for_db()) as s:
+        for r in rows:
+            row = (
+                await s.exec(
+                    select(PredefinedQuery).where(
+                        PredefinedQuery.type == r["type"],
+                        PredefinedQuery.query_name == r["query_name"],
+                        PredefinedQuery.workspace_id == workspace_id,
+                    )
+                )
+            ).first()
+            if row is None:
+                row = PredefinedQuery(query_name=r["query_name"], type=r["type"], workspace_id=workspace_id, query="")
+            row.query = r["query"] or ""
+            row.cell_view = r.get("cell_view")
+            row.order_by = r.get("order_by")
+            row.fields = r.get("fields")
+            s.add(row)
+        await s.commit()
+
+
+async def save_predefined_query(
+    query_name: str,
+    conn_type: str,
+    query: str,
+    cell_view: str | None = None,
+    order_by: str | None = None,
+    fields: str | None = None,
+    *,
+    workspace_id: int,
+) -> None:
+    """Upsert a predefined query by (workspace, type, query_name)."""
+    await save_predefined_queries(
+        [
+            {
+                "type": conn_type,
+                "query_name": query_name,
+                "query": query,
+                "cell_view": cell_view,
+                "order_by": order_by,
+                "fields": fields,
+            }
+        ],
+        workspace_id=workspace_id,
+    )

queryview/remote.py

@@ -0,0 +1,141 @@
+"""In-memory push hub for remote control: one message queue per armed browser
+channel, keyed by a random public id. SSE framing and disconnect handling live
+in main.py."""
+
+from __future__ import annotations
+
+import asyncio
+import secrets
+import time
+from dataclasses import dataclass, field
+from typing import Any
+
+from .validation import cell_view_error, presentation_error
+
+LOCK_TTL_SECONDS = 30.0
+
+
+@dataclass
+class _Channel:
+    queue: asyncio.Queue[dict[str, Any]] = field(default_factory=asyncio.Queue)
+    # Advisory edit lock: "human" | "agent" | None. lock_touched is a monotonic
+    # timestamp refreshed on acquire; a human lock older than LOCK_TTL_SECONDS is
+    # treated as released (heartbeat lapsed / tab froze).
+    lock_owner: str | None = None
+    lock_touched: float = 0.0
+    # The database this browser session currently targets, reported by the UI so
+    # push_query/push_dashboard can echo it back to the agent.
+    database: str | None = None
+    # The workspace this browser session is on, reported by the UI like
+    # `database`, so session-scoped MCP tools resolve against it.
+    workspace: str | None = None
+
+
+# remote_id -> channel. Module-level, like connect.py's _sessions.
+_channels: dict[str, _Channel] = {}
+
+
+def _human_holds(channel: _Channel) -> bool:
+    return channel.lock_owner == "human" and (time.monotonic() - channel.lock_touched) < LOCK_TTL_SECONDS
+
+
+def acquire(remote_id: str, owner: str) -> tuple[bool, str]:
+    """Take (or refresh) the edit lock for `owner`. Succeeds if free, already
+    yours, or the current holder's TTL has lapsed. Otherwise returns the
+    owner-named block reason."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return False, "unknown or inactive session"
+    now = time.monotonic()
+    expired = (now - channel.lock_touched) >= LOCK_TTL_SECONDS
+    if channel.lock_owner in (None, owner) or expired:
+        channel.lock_owner = owner
+        channel.lock_touched = now
+        return True, "acquired"
+    who = "user" if channel.lock_owner == "human" else "agent"
+    return False, f"blocked, {who} editing"
+
+
+def release(remote_id: str, owner: str) -> tuple[bool, str]:
+    """Release the lock only if `owner` holds it (idempotent)."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return False, "unknown or inactive session"
+    if channel.lock_owner == owner:
+        channel.lock_owner = None
+    return True, "released"
+
+
+def register() -> str:
+    """Create a channel for a newly-armed browser session; return its public id.
+    The id is random and unrelated to the qv_session cookie, so the session secret
+    is never exposed to the agent."""
+    remote_id = secrets.token_hex(8)
+    _channels[remote_id] = _Channel()
+    return remote_id
+
+
+def unregister(remote_id: str) -> None:
+    """Drop a channel (idempotent)."""
+    _channels.pop(remote_id, None)
+
+
+def set_session_database(remote_id: str, database: str | None) -> bool:
+    """Record the database a live session targets (reported by the UI). Returns
+    False for an unknown/inactive session."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return False
+    channel.database = database
+    return True
+
+
+def session_database(remote_id: str) -> str | None:
+    """The database a live session targets, or None if unknown/unreported."""
+    channel = _channels.get(remote_id)
+    return channel.database if channel else None
+
+
+def set_session_workspace(remote_id: str, workspace: str | None) -> bool:
+    """Record the workspace a live session is on (reported by the UI). Returns
+    False for an unknown/inactive session."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return False
+    channel.workspace = workspace
+    return True
+
+
+def session_workspace(remote_id: str) -> str | None:
+    """The workspace a live session is on, or None if unknown/unreported."""
+    channel = _channels.get(remote_id)
+    return channel.workspace if channel else None
+
+
+def push(remote_id: str, payload: dict[str, Any]) -> tuple[bool, str]:
+    """Validate + lock-check + enqueue a payload for a channel. Ordered:
+    unknown session -> invalid presentation -> human holds lock -> deliver."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return False, "unknown or inactive session"
+    err = presentation_error(payload.get("order_by"), payload.get("fields")) or cell_view_error(
+        payload.get("cell_view")
+    )
+    if err is not None:
+        return False, err
+    if _human_holds(channel):
+        return False, "blocked, user editing"
+    channel.queue.put_nowait(payload)
+    return True, "delivered"
+
+
+async def next_message(remote_id: str, timeout: float) -> dict[str, Any] | None:
+    """Wait up to `timeout` seconds for the next payload on a channel. Returns
+    None on timeout or if the channel is gone."""
+    channel = _channels.get(remote_id)
+    if channel is None:
+        return None
+    try:
+        return await asyncio.wait_for(channel.queue.get(), timeout)
+    except TimeoutError:
+        return None