quickdbd-cli 0.1.15__tar.gz → 0.1.16__tar.gz

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quickdbd-cli
-Version: 0.1.15
+Version: 0.1.16
 Summary: Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit.
 Project-URL: Homepage, https://github.com/MarkPhamm/quickdbd-cli
 Author: Minh (Mark) Pham
@@ -65,6 +65,7 @@ qdbd is not affiliated with QuickDBD. It reads the same text syntax, so schemas
 - **dbt import**: `qdbd import dbt` reads `manifest.json`. Primary keys come from `unique` + `not_null` tests or constraints, relationships from `relationships` tests, and `--infer-fks` fills the gaps from column names.
 - **Readable at 200+ tables**: automatic layout, search, dbt-style selectors (`+orders+1`, `group:marts`, `tag:fact`), shaded regions per file, collapsed views and a minimap.
 - **Review changes in pull requests**: `qdbd diff` reports what a branch changed, the GitHub Action posts it as a PR comment, and `--diff-base` colours the changes in the diagram.
+- **VS Code extension**: highlighting, errors as you type, outline, F12 across files, and the diagram beside the editor, following your cursor ([docs](https://qdbd.dev/vscode/)).
 - **One schema, many outputs**: an HTML page, PNG, SVG, editable draw.io, or a shareable link. Installs with pip: no Node, Graphviz or browser needed.
 
 ## Demo gallery
@@ -135,6 +136,8 @@ qdbd serve schema.txt
 
 Edit in the browser or in your own editor; the diagram reloads on save. Dragged positions are saved to `schema.layout.json`, which you commit next to the schema.
 
+In VS Code (or Cursor), the [extension](https://qdbd.dev/vscode/) does the same inside the editor, with errors as you type and the diagram following your cursor. Install the `.vsix` from the [latest release](https://github.com/MarkPhamm/quickdbd-cli/releases/latest).
+
 #### 4. Build, export and share
 
 ```sh

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/README.md

@@ -37,6 +37,7 @@ qdbd is not affiliated with QuickDBD. It reads the same text syntax, so schemas
 - **dbt import**: `qdbd import dbt` reads `manifest.json`. Primary keys come from `unique` + `not_null` tests or constraints, relationships from `relationships` tests, and `--infer-fks` fills the gaps from column names.
 - **Readable at 200+ tables**: automatic layout, search, dbt-style selectors (`+orders+1`, `group:marts`, `tag:fact`), shaded regions per file, collapsed views and a minimap.
 - **Review changes in pull requests**: `qdbd diff` reports what a branch changed, the GitHub Action posts it as a PR comment, and `--diff-base` colours the changes in the diagram.
+- **VS Code extension**: highlighting, errors as you type, outline, F12 across files, and the diagram beside the editor, following your cursor ([docs](https://qdbd.dev/vscode/)).
 - **One schema, many outputs**: an HTML page, PNG, SVG, editable draw.io, or a shareable link. Installs with pip: no Node, Graphviz or browser needed.
 
 ## Demo gallery
@@ -107,6 +108,8 @@ qdbd serve schema.txt
 
 Edit in the browser or in your own editor; the diagram reloads on save. Dragged positions are saved to `schema.layout.json`, which you commit next to the schema.
 
+In VS Code (or Cursor), the [extension](https://qdbd.dev/vscode/) does the same inside the editor, with errors as you type and the diagram following your cursor. Install the `.vsix` from the [latest release](https://github.com/MarkPhamm/quickdbd-cli/releases/latest).
+
 #### 4. Build, export and share
 
 ```sh

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quickdbd-cli"
-version = "0.1.15"
+version = "0.1.16"
 description = "Compile QuickDBD-syntax schema files into interactive HTML ER diagrams, with no table limit."
 readme = "README.md"
 license = "Apache-2.0"

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/scripts/release.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 # Build and upload the current version to PyPI using credentials from .env,
-# then tag and create the GitHub release.
+# then tag and create the GitHub release, with the VS Code extension (.vsix) attached.
 # Usage: bump `version` in pyproject.toml and src/quickdbd_cli/__init__.py, commit, then run
 #   PATH="$PWD/.venv/bin:$PATH" scripts/release.sh
 set -euo pipefail
@@ -20,9 +20,16 @@ python3 -c "import build, twine" 2>/dev/null || {
 }
 python3 -m build
 python3 -m twine check dist/*
+
+# The extension is packaged before anything is uploaded, so a Node problem doesn't leave half a release.
+node -e 'process.exit(+process.versions.node.split(".")[0] >= 20 ? 0 : 1)' 2>/dev/null || {
+  echo "error: packaging the VS Code extension needs Node 20+ on PATH" >&2; exit 1; }
+rm -f vscode/*.vsix
+(cd vscode && npm ci --no-audit --no-fund && npm run -s package)
+vsix=$(ls vscode/*.vsix)
 python3 -m twine upload --non-interactive dist/*
 
 git tag -a "v$version" -m "qdbd v$version"
 git push origin "v$version"
-gh release create "v$version" dist/* --title "qdbd v$version" --generate-notes
+gh release create "v$version" dist/* "$vsix" --title "qdbd v$version" --generate-notes
 echo "Released v$version: https://pypi.org/project/quickdbd-cli/$version/"

quickdbd_cli-0.1.16/src/quickdbd_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.16"

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/src/quickdbd_cli/assets/viewer.js

@@ -240,7 +240,9 @@
     var d = drag;
     drag = null;
     if (!d.moved) {
-      select(d.table && S.focus !== d.table ? d.table : null);
+      // Clicking the selected table toggles it off, unless it was selected quietly: then show its details.
+      if (d.table && d.table === S.focus && !details.classList.contains("open")) showDetails(d.table);
+      else select(d.table && S.focus !== d.table ? d.table : null);
       return;
     }
     if (d.start) {
@@ -294,6 +296,7 @@
     try { var t = localStorage.getItem("qdbd-theme"); return t === "light" || t === "dark" ? t : "auto"; } catch (e) { return "auto"; }
   }
   function applyTheme() {
+    if (data.embed) return; // the editor sets the theme (qdbd.theme message)
     var pref = themePref(), t = pref === "auto" ? (darkQuery.matches ? "dark" : "light") : pref;
     document.documentElement.setAttribute("data-theme", t);
     themeBtn.title = "Theme: " + pref;
@@ -315,12 +318,13 @@
   }
 
   /* ------------------------------------------------------------- selection: focus + details */
+  /* opts.center: pan to it. opts.quiet: don't open the details panel (only refresh it if it's already open). */
   function select(id, opts) {
     if ((id || null) !== S.focus) S.path = null;
     S.focus = id && byId[id] ? id : null;
     scheduleHash();
     applyFocus();
-    if (S.focus) showDetails(S.focus);
+    if (S.focus && (!(opts && opts.quiet) || details.classList.contains("open"))) showDetails(S.focus);
     else closeDetails();
     markTree();
     if (S.focus && opts && opts.center) centerOn(S.focus);
@@ -513,7 +517,10 @@
       (t.diff.state === "added" ? "NEW" : "CHANGED") + "</span>" : "") + "</h2>");
     var meta = [];
     if (t.aliases.length) meta.push("as " + Q.esc(t.aliases.join(", ")));
-    if (t.file) meta.push(Q.esc(t.file) + ":" + t.line);
+    if (t.file) {
+      var where = Q.esc(t.file) + ":" + t.line;
+      meta.push(data.embed ? '<a class="reveal" title="Open in the editor">' + where + "</a>" : where);
+    }
     if (meta.length) out.push('<div class="meta">' + meta.join(" &middot; ") + "</div>");
     if (t.tags) {
       out.push('<div class="ttags">' + t.tags.map(function (g) {
@@ -684,6 +691,40 @@
     img.src = "data:image/svg+xml;charset=utf-8," + encodeURIComponent(text);
   };
 
+  /* ------------------------------------------------------------- embed: the VS Code preview (qdbd serve --embed)
+   * The page sits in an iframe inside a webview. It posts qdbd.ready / qdbd.reveal {file, line} to the parent and
+   * takes qdbd.focus {table} and qdbd.theme {theme}. Downloads and the clipboard don't work there, so the
+   * extension's commands replace the export, link and theme buttons. */
+  if (data.embed) {
+    ["xsvg", "xpng", "xdrawio", "xlink", "xtheme"].forEach(function (id) { document.getElementById(id).style.display = "none"; });
+    window.qdbdServe = {
+      saveLayout: function (body) {
+        fetch("layout", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+      },
+    };
+    var reveal = function (id) {
+      var t = byId[id];
+      if (t && t.file) window.parent.postMessage({ type: "qdbd.reveal", file: t.file, line: t.line }, "*");
+    };
+    svg.addEventListener("dblclick", function (ev) {
+      var g = ev.target.closest(".t");
+      if (g) reveal(g.getAttribute("data-id"));
+    });
+    dbody.addEventListener("click", function (ev) { if (ev.target.closest("a.reveal")) reveal(S.focus); });
+    window.addEventListener("message", function (ev) {
+      var m = ev.data;
+      if (ev.source !== window.parent || !m) return;
+      if (m.type === "qdbd.focus") {
+        var t = S.model.tables.filter(function (x) { return x.name === m.table; })[0];
+        // Follows the editor's cursor: highlight and pan, but don't cover the diagram with the details panel.
+        if (t && t.id !== S.focus && S.shown[t.id]) select(t.id, { center: true, quiet: true });
+      } else if (m.type === "qdbd.theme") {
+        document.documentElement.setAttribute("data-theme", m.theme === "dark" ? "dark" : "light");
+      }
+    });
+    window.parent.postMessage({ type: "qdbd.ready" }, "*");
+  }
+
   /* ------------------------------------------------------------- public API (serve mode) */
   window.qdbdViewer = {
     setData: function (model, positions) {

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/src/quickdbd_cli/cli.py

@@ -50,13 +50,41 @@ def _github_annotation(d: Diagnostic, level: str) -> str:
     return f"::{level} file={esc_prop(d.path)},line={d.line},title=qdbd::{esc(d.message)}"
 
 
+def _symbols(schema: Schema) -> dict:
+    """Tables, columns and relationships with their source lines, for editor outlines and go-to-definition."""
+    tables = []
+    for t in schema.tables.values():
+        cols = [{"name": c.name, "line": c.line} for c in t.columns.values() if not c.virtual]
+        end = max([t.line + 1] + [c["line"] for c in cols])
+        tables.append(
+            {"name": t.name, "aliases": t.aliases, "file": t.path, "line": t.line, "endLine": end, "columns": cols}
+        )
+
+    def end(e) -> dict:
+        t = schema.tables.get(e.table)
+        c = t.columns.get(e.column) if t else None
+        return {"table": t.name if t else e.table, "column": c.name if c and not c.virtual else None}
+
+    rels = [{"file": r.path, "line": r.line, "a": end(r.a), "b": end(r.b)} for r in schema.relationships]
+    return {"tables": tables, "rels": rels}
+
+
 def cmd_check(args) -> int:
     project = _open(args)
-    schema = project.compile()
+    overrides = None
+    if args.stdin_file:
+        target = Path(args.stdin_file).resolve()
+        if target not in {f.resolve() for f in project.files}:
+            print(f"error: --stdin-file {args.stdin_file} is not one of the schema files", file=sys.stderr)
+            return 2
+        overrides = {target: sys.stdin.read()}
+    schema = project.compile(overrides)
     if args.format == "json":
         ok = not schema.errors and not (args.strict and schema.warnings)
         diags = [dataclasses.asdict(d) for d in schema.diagnostics]
         report = {"ok": ok, "errors": len(schema.errors), "warnings": len(schema.warnings), "diagnostics": diags}
+        if args.symbols:
+            report.update(_symbols(schema))
         print(json.dumps(report, indent=2))
         return 0 if ok else 1
     if args.format == "github":
@@ -344,7 +372,12 @@ def cmd_serve(args) -> int:
     project = _open(args)
     # Without --port, a busy 8765 (e.g. a second `qdbd serve`) moves on to the next free port.
     port, tries = (args.port, 1) if args.port is not None else (8765, 20)
-    return serve(project, port=port, open_browser=not args.no_open, read_only=args.read_only, tries=tries)
+    if args.read_only and args.embed:
+        print("error: --read-only and --embed don't go together", file=sys.stderr)
+        return 2
+    return serve(
+        project, port=port, open_browser=not args.no_open, read_only=args.read_only, tries=tries, embed=args.embed
+    )
 
 
 def build_parser() -> argparse.ArgumentParser:
@@ -375,6 +408,14 @@ def build_parser() -> argparse.ArgumentParser:
         default="text",
         help="github: also emit GitHub Actions annotations (inline on PR lines); json: a machine-readable report",
     )
+    sp.add_argument(
+        "--symbols", action="store_true", help="with --format json: also list tables, columns and relationships"
+    )
+    sp.add_argument(
+        "--stdin-file",
+        metavar="PATH",
+        help="read this schema file's text from stdin instead of disk (an editor's unsaved buffer)",
+    )
     sp.set_defaults(func=cmd_check)
 
     sp = sub.add_parser("build", help="write an interactive HTML diagram")
@@ -477,6 +518,11 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="live view only: no editor, nothing saved; safe to share through a tunnel",
     )
+    sp.add_argument(
+        "--embed",
+        action="store_true",
+        help="for the VS Code extension's preview: no editor pane, dragging saves the layout",
+    )
     sp.set_defaults(func=cmd_serve)
     return p
 

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/src/quickdbd_cli/html.py

@@ -115,8 +115,10 @@ FILTER_HELP = (
 
 
 # Runs in <head> so the page paints in the right theme. viewer.js owns the toggle; keep the key in sync.
+# ?theme=dark|light (the VS Code preview passes its theme) wins over the saved choice.
 THEME_JS = (
-    "(function(){var t;try{t=localStorage.getItem('qdbd-theme');}catch(e){}"
+    "(function(){var t=(/[?&]theme=(dark|light)/.exec(location.search)||[])[1];"
+    "if(!t)try{t=localStorage.getItem('qdbd-theme');}catch(e){}"
     "if(t!=='light'&&t!=='dark')t=matchMedia('(prefers-color-scheme: dark)').matches?'dark':'light';"
     "document.documentElement.setAttribute('data-theme',t);})();"
 )
@@ -131,11 +133,18 @@ LIVE_JS = (
 )
 
 
-def render_page(model: dict, positions: dict, title: str, serve: bool = False, live: bool = False) -> str:
+def render_page(
+    model: dict, positions: dict, title: str, serve: bool = False, live: bool = False, embed: bool = False
+) -> str:
     """The self-contained page. ``serve``: editor pane and saved dragging. ``live``: read-only, but reloads
-    when the server's schema changes (``qdbd serve --read-only``)."""
-    data = {"model": model, "positions": positions, "serve": serve, "title": title}
-    if serve:
+    when the server's schema changes (``qdbd serve --read-only``). ``embed``: live reload and saved dragging,
+    no editor pane; talks to the VS Code extension through postMessage (``qdbd serve --embed``)."""
+    data = {"model": model, "positions": positions, "serve": serve or embed, "title": title}
+    if embed:
+        data["embed"] = True
+    if embed:
+        hint = "Drag tables to arrange them (saved). Double-click a table to open it in the editor."
+    elif serve:
         hint = "Drag tables to arrange them (saved). Click a table for details. Esc clears."
     elif live:
         hint = "Live, read-only view: updates when the schema changes. Drag tables to rearrange (not saved)."
@@ -155,7 +164,7 @@ def render_page(model: dict, positions: dict, title: str, serve: bool = False, l
             f'<script src="{CODEMIRROR}/addon/mode/simple.min.js"></script>'
             f"<script>{_asset('editor.js')}</script>"
         )
-    elif live:
+    elif live or embed:
         scripts = f"<script>{LIVE_JS}</script>"
     return (
         '<!doctype html>\n<html lang="en"><head><meta charset="utf-8">'

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/src/quickdbd_cli/project.py

@@ -52,11 +52,16 @@ class Project:
             raise FileNotFoundError("no .txt schema files found in: " + ", ".join(map(str, inputs)))
         return cls(inputs, files, sidecar or layout.default_sidecar(files, inputs))
 
-    def sources(self) -> list[tuple[str, str]]:
-        return [(display_path(f), f.read_text(encoding="utf-8")) for f in self.files]
-
-    def compile(self) -> Schema:
-        return compile_sources(self.sources())
+    def sources(self, overrides: dict[Path, str] | None = None) -> list[tuple[str, str]]:
+        """``overrides``: text to use instead of a file on disk, by resolved path (an editor's unsaved buffer)."""
+        over = {p.resolve(): t for p, t in (overrides or {}).items()}
+        return [
+            (display_path(f), over[f.resolve()] if f.resolve() in over else f.read_text(encoding="utf-8"))
+            for f in self.files
+        ]
+
+    def compile(self, overrides: dict[Path, str] | None = None) -> Schema:
+        return compile_sources(self.sources(overrides))
 
     def build(
         self, schema: Schema, reset: bool = False, select: str | None = None, by_group: bool = False

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/src/quickdbd_cli/serve.py

@@ -4,7 +4,8 @@ Watches the schema files (mtime polling), recompiles on change and pushes a relo
 page over Server-Sent Events. Dragged table positions are saved to the layout sidecar; the
 browser editor pane writes the .txt files, refusing to overwrite a file changed on disk since
 the browser last loaded it. With ``read_only`` the page is the plain viewer plus live reload, and
-the server never writes anything.
+the server never writes anything. With ``embed`` (the VS Code extension's preview) the page is the
+viewer plus live reload; dragging still saves the layout, but files are only edited in VS Code.
 """
 
 from __future__ import annotations
@@ -17,6 +18,7 @@ import time
 import webbrowser
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
+from urllib.parse import urlsplit
 
 from . import layout
 from .html import render_page
@@ -24,9 +26,10 @@ from .project import Project, discover, display_path
 
 
 class State:
-    def __init__(self, project: Project, read_only: bool = False):
+    def __init__(self, project: Project, read_only: bool = False, embed: bool = False):
         self.project = project
         self.read_only = read_only  # never write to disk: no editor saves, no layout file
+        self.embed = embed  # an editor owns the files: layout saves only
         self.lock = threading.Condition()
         self.version = 0
         self.model: dict = {"style": {}, "tables": [], "rels": [], "zoom": None, "position": None}
@@ -80,7 +83,7 @@ class State:
 
     def snapshot(self) -> dict:
         with self.lock:
-            if self.read_only:  # the model only: no file text, no diagnostics
+            if self.read_only or self.embed:  # the model only: no file text, no diagnostics
                 return {"version": self.version, "model": self.model, "positions": self.positions}
             files = []
             for f in self.files:
@@ -138,16 +141,19 @@ def _handler(state: State, title: str):
             return json.loads(self.rfile.read(n) or b"{}")
 
         def do_GET(self) -> None:
-            if self.path == "/":
+            path = urlsplit(self.path).path  # the page may carry ?theme=
+            if path == "/":
                 with state.lock:
                     if state.read_only:
                         page = render_page(state.model, state.positions, title, live=True)
+                    elif state.embed:
+                        page = render_page(state.model, state.positions, title, embed=True)
                     else:
                         page = render_page(state.model, state.positions, title, serve=True)
                 self._send(200, page.encode(), "text/html; charset=utf-8")
-            elif self.path == "/state":
+            elif path == "/state":
                 self._json(200, state.snapshot())
-            elif self.path == "/events":
+            elif path == "/events":
                 self.send_response(200)
                 self.send_header("Content-Type", "text/event-stream")
                 self.send_header("Cache-Control", "no-store")
@@ -164,7 +170,7 @@ def _handler(state: State, title: str):
                         self.wfile.flush()
                 except (BrokenPipeError, ConnectionResetError, OSError):
                     return
-            elif self.path == "/favicon.ico":
+            elif path == "/favicon.ico":
                 self._send(204, b"", "image/x-icon")
             else:
                 self._send(404, b"not found", "text/plain")
@@ -179,7 +185,7 @@ def _handler(state: State, title: str):
                 self._send(404, b"not found", "text/plain")
 
         def do_PUT(self) -> None:
-            if state.read_only:
+            if state.read_only or state.embed:
                 self._json(403, {"error": "read-only"})
             elif self.path == "/file":
                 b = self._body()
@@ -196,11 +202,11 @@ class PortInUse(OSError):
 
 
 def make_server(
-    project: Project, port: int = 8765, read_only: bool = False, tries: int = 1
+    project: Project, port: int = 8765, read_only: bool = False, tries: int = 1, embed: bool = False
 ) -> tuple[ThreadingHTTPServer, State]:
     """Bind the HTTP server without starting it. Port 0 picks a free port; with ``tries`` > 1, a busy port
     moves on to the next one (port, port+1, ...)."""
-    state = State(project, read_only=read_only)
+    state = State(project, read_only=read_only, embed=embed)
     title = project.inputs[0].stem if len(project.inputs) == 1 else "diagram"
     server = None
     for p in range(port, port + max(tries, 1)) if port else [0]:
@@ -230,10 +236,15 @@ def poll_once(state: State) -> bool:
 
 
 def serve(
-    project: Project, port: int = 8765, open_browser: bool = True, read_only: bool = False, tries: int = 1
+    project: Project,
+    port: int = 8765,
+    open_browser: bool = True,
+    read_only: bool = False,
+    tries: int = 1,
+    embed: bool = False,
 ) -> int:
     try:
-        server, state = make_server(project, port, read_only=read_only, tries=tries)
+        server, state = make_server(project, port, read_only=read_only, tries=tries, embed=embed)
     except PortInUse as e:
         print(f"error: {e}", file=sys.stderr)
         return 2

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/tests/test_pipeline.py

@@ -171,6 +171,33 @@ def test_check_format_json(tmp_path, capsys):
     ]
 
 
+def test_check_symbols_list_tables_columns_and_rels(tmp_path, capsys):
+    f = tmp_path / "shop.txt"
+    f.write_text(SMALL)
+    assert main(["check", "--format", "json", "--symbols", str(f)]) == 0
+    r = json.loads(capsys.readouterr().out)
+    order = next(t for t in r["tables"] if t["name"] == "Order")
+    assert order["file"].endswith("shop.txt") and order["line"] < order["endLine"]
+    assert [c["name"] for c in order["columns"]] and all(c["line"] > order["line"] for c in order["columns"])
+    assert {(x["a"]["table"], x["b"]["table"]) for x in r["rels"]} == {("Order", "Customer")}
+    assert main(["check", "--format", "json", str(f)]) == 0
+    assert "tables" not in json.loads(capsys.readouterr().out)  # only with --symbols
+
+
+def test_check_stdin_file_uses_the_unsaved_text(tmp_path, capsys, monkeypatch):
+    import io
+
+    f = tmp_path / "shop.txt"
+    f.write_text(SMALL)
+    monkeypatch.setattr("sys.stdin", io.StringIO("Broken\n-\nId int FK >- Nope.Id\n"))
+    assert main(["check", "--format", "json", "--stdin-file", str(f), str(tmp_path)]) == 1
+    r = json.loads(capsys.readouterr().out)
+    assert r["errors"] and "Nope" in r["diagnostics"][0]["message"]
+    assert f.read_text() == SMALL
+    monkeypatch.setattr("sys.stdin", io.StringIO(""))
+    assert main(["check", "--stdin-file", str(tmp_path / "other.txt"), str(f)]) == 2
+
+
 def test_check_format_json_ok(capsys):
     assert main(["check", "--format", "json", str(SAMPLE)]) == 0
     data = json.loads(capsys.readouterr().out)

{quickdbd_cli-0.1.15 → quickdbd_cli-0.1.16}/tests/test_serve.py

@@ -196,6 +196,37 @@ def test_read_only_refuses_writes_and_never_touches_disk(ro):
     assert not f.with_name("shop.layout.json").exists()
 
 
+# ------------------------------------------------------------------ --embed (VS Code preview)
+
+
+@pytest.fixture
+def emb(tmp_path):
+    f = tmp_path / "shop.txt"
+    f.write_text(SCHEMA)
+    server, state = make_server(Project.open([f]), port=0, embed=True)
+    threading.Thread(target=server.serve_forever, daemon=True).start()
+    yield f"http://127.0.0.1:{server.server_address[1]}", state, f
+    server.shutdown()
+    server.server_close()
+
+
+def test_embed_page_is_the_viewer_with_live_reload(emb):
+    base, _, _ = emb
+    code, page = call(base, "/?theme=dark")  # the query must not break routing
+    assert code == 200 and b'id="side"' not in page and b'"embed":true' in page
+    assert b"codemirror.min.js" not in page and b"EventSource('events')" in page
+    code, st = call(base, "/state")
+    assert code == 200 and set(st) == {"version", "model", "positions"}
+
+
+def test_embed_saves_layout_but_never_edits_files(emb):
+    base, _, f = emb
+    assert call(base, "/file", "PUT", {"path": display_path(f), "text": "x", "mtime": None})[0] == 403
+    assert f.read_text() == SCHEMA
+    assert call(base, "/layout", "POST", {"Customer": [10, 20]})[0] == 200
+    assert layout.read_sidecar(f.with_name("shop.layout.json"))["Customer"] == (10, 20)
+
+
 # ------------------------------------------------------------------ busy ports