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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quickdbd-cli
-Version: 0.1.16
+Version: 0.1.17
 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
@@ -136,7 +136,7 @@ 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).
+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. Search **QuickDBD** in the Extensions view: it's on the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=MarkPhamm.quickdbd) and [Open VSX](https://open-vsx.org/extension/MarkPhamm/quickdbd).
 
 #### 4. Build, export and share
 

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

@@ -108,7 +108,7 @@ 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).
+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. Search **QuickDBD** in the Extensions view: it's on the [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=MarkPhamm.quickdbd) and [Open VSX](https://open-vsx.org/extension/MarkPhamm/quickdbd).
 
 #### 4. Build, export and share
 

quickdbd_cli-0.1.17/examples/quickdbd-sample.layout.json

@@ -0,0 +1,33 @@
+{
+  "tables": {
+    "Address": {
+      "x": -104,
+      "y": 207
+    },
+    "Customer": {
+      "x": 202,
+      "y": 259
+    },
+    "Order": {
+      "x": 482,
+      "y": 164
+    },
+    "OrderLine": {
+      "x": 735,
+      "y": 59
+    },
+    "Product": {
+      "x": 966,
+      "y": 106
+    },
+    "Product Catalog": {
+      "x": 1271,
+      "y": -129
+    },
+    "Wishlist": {
+      "x": 192,
+      "y": 560
+    }
+  },
+  "version": 1
+}

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "quickdbd-cli"
-version = "0.1.16"
+version = "0.1.17"
 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.16 → quickdbd_cli-0.1.17}/scripts/release.sh

@@ -1,6 +1,9 @@
 #!/usr/bin/env bash
 # Build and upload the current version to PyPI using credentials from .env,
 # then tag and create the GitHub release, with the VS Code extension (.vsix) attached.
+# With OVSX_PAT in .env, the extension also goes to Open VSX (Cursor, Windsurf, VSCodium) when its version is new.
+# The VS Code Marketplace takes a manual upload (an automation token needs an Azure subscription); the script
+# says when one is due.
 # 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
@@ -22,8 +25,8 @@ 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; }
+node -e 'process.exit(+process.versions.node.split(".")[0] >= 22 ? 0 : 1)' 2>/dev/null || {
+  echo "error: packaging the VS Code extension needs Node 22+ 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)
@@ -33,3 +36,18 @@ git tag -a "v$version" -m "qdbd v$version"
 git push origin "v$version"
 gh release create "v$version" dist/* "$vsix" --title "qdbd v$version" --generate-notes
 echo "Released v$version: https://pypi.org/project/quickdbd-cli/$version/"
+
+ext_version=$(node -p 'require("./vscode/package.json").version')
+if [ -n "${OVSX_PAT:-}" ]; then
+  vscode/node_modules/.bin/ovsx publish "$vsix" -p "$OVSX_PAT" --skip-duplicate
+else
+  echo "note: OVSX_PAT isn't set in .env, so the extension wasn't published to Open VSX"
+fi
+on_marketplace=$(curl -s -X POST https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery \
+  -H "Content-Type: application/json" -H "Accept: application/json;api-version=7.2-preview.1" \
+  -d '{"filters":[{"criteria":[{"filterType":7,"value":"MarkPhamm.quickdbd"}]}],"flags":1}' |
+  python3 -c 'import json,sys; e=json.load(sys.stdin)["results"][0]["extensions"]; print(e[0]["versions"][0]["version"] if e else "")' ||
+  true)
+if [ "$on_marketplace" != "$ext_version" ]; then
+  echo "action: upload $vsix (extension $ext_version) at https://marketplace.visualstudio.com/manage/publishers/markphamm"
+fi

quickdbd_cli-0.1.17/src/quickdbd_cli/__init__.py

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

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

@@ -735,6 +735,7 @@
       render();
       applyView();
       drawTree();
+      drawDiffBar(); // serve --diff-base: the counts change as you edit
       if (S.focus && byId[S.focus]) showDetails(S.focus);
       else select(null);
     },

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

@@ -376,7 +376,13 @@ def cmd_serve(args) -> int:
         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
+        project,
+        port=port,
+        open_browser=not args.no_open,
+        read_only=args.read_only,
+        tries=tries,
+        embed=args.embed,
+        diff_base=args.diff_base,
     )
 
 
@@ -523,6 +529,9 @@ def build_parser() -> argparse.ArgumentParser:
         action="store_true",
         help="for the VS Code extension's preview: no editor pane, dragging saves the layout",
     )
+    sp.add_argument(
+        "--diff-base", metavar="GIT_REF", help="colour tables/columns changed since this git ref (e.g. origin/main)"
+    )
     sp.set_defaults(func=cmd_serve)
     return p
 

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

@@ -5,7 +5,8 @@ page over Server-Sent Events. Dragged table positions are saved to the layout si
 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. 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.
+viewer plus live reload; dragging still saves the layout, but files are only edited in VS Code. With
+``diff_base`` every reload is coloured by its changes since that git ref, like ``build --diff-base``.
 """
 
 from __future__ import annotations
@@ -20,16 +21,18 @@ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path
 from urllib.parse import urlsplit
 
-from . import layout
+from . import diff, layout
 from .html import render_page
 from .project import Project, discover, display_path
 
 
 class State:
-    def __init__(self, project: Project, read_only: bool = False, embed: bool = False):
+    def __init__(self, project: Project, read_only: bool = False, embed: bool = False, diff_base: str | None = None):
         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.diff_base = diff_base
+        self.base = diff.schema_at_ref(diff_base, project.inputs) if diff_base else None  # read once
         self.lock = threading.Condition()
         self.version = 0
         self.model: dict = {"style": {}, "tables": [], "rels": [], "zoom": None, "position": None}
@@ -59,6 +62,8 @@ class State:
                 from .measure import model_json
 
                 model = model_json(schema)
+                if self.base is not None:
+                    diff.annotate_model(model, diff.diff_schemas(self.base, schema), self.diff_base)
                 base = layout.read_sidecar(self.project.sidecar)
                 current = {
                     t["name"]: tuple(self.positions[t["id"]]) for t in self.model["tables"] if t["id"] in self.positions
@@ -202,11 +207,16 @@ class PortInUse(OSError):
 
 
 def make_server(
-    project: Project, port: int = 8765, read_only: bool = False, tries: int = 1, embed: bool = False
+    project: Project,
+    port: int = 8765,
+    read_only: bool = False,
+    tries: int = 1,
+    embed: bool = False,
+    diff_base: str | None = None,
 ) -> 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, embed=embed)
+    moves on to the next one (port, port+1, ...). Raises ``diff.DiffError`` for a ``diff_base`` git can't read."""
+    state = State(project, read_only=read_only, embed=embed, diff_base=diff_base)
     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]:
@@ -242,10 +252,11 @@ def serve(
     read_only: bool = False,
     tries: int = 1,
     embed: bool = False,
+    diff_base: str | None = None,
 ) -> int:
     try:
-        server, state = make_server(project, port, read_only=read_only, tries=tries, embed=embed)
-    except PortInUse as e:
+        server, state = make_server(project, port, read_only=read_only, tries=tries, embed=embed, diff_base=diff_base)
+    except (PortInUse, diff.DiffError) as e:
         print(f"error: {e}", file=sys.stderr)
         return 2
     for d in state.diagnostics:

{quickdbd_cli-0.1.16 → quickdbd_cli-0.1.17}/src/quickdbd_cli/share.py

@@ -2,7 +2,8 @@
 
 Uses the GitHub CLI (``gh api``), so it inherits the user's login. Gists are secret (unlisted) unless
 ``public``. The gist made for each input/selection is remembered in the user's cache directory, so
-sharing again updates the same gist and the link stays the same.
+sharing again updates the same gist and the link stays the same. The VS Code extension does the same
+without gh (vscode/src/gist.ts) and shares the cache: keep the two in step.
 """
 
 from __future__ import annotations

{quickdbd_cli-0.1.16 → quickdbd_cli-0.1.17}/tests/test_diff.py

@@ -125,3 +125,30 @@ def test_build_diff_base_marks_model(repo, capsys):
     sel = repo / "s.html"
     assert main(["build", str(repo / "erd"), "--diff-base", "main", "-s", "diff:added", "-o", str(sel)]) == 0
     assert "(1 tables" in capsys.readouterr().out.splitlines()[-1]
+
+
+def test_serve_diff_base_colours_the_live_model(repo):
+    import os
+
+    from quickdbd_cli.project import Project
+    from quickdbd_cli.serve import make_server, poll_once
+
+    server, state = make_server(Project.open([repo / "erd"]), port=0, embed=True, diff_base="main")
+    server.server_close()
+    tables = {t["name"]: t for t in state.model["tables"]}
+    assert tables["products"]["diff"] == {"state": "added"}
+    assert tables["customers"]["diff"]["removedCols"] == ["legacy_flag"]
+    assert state.model["diff"]["base"] == "main" and state.model["diff"]["removed"] == ["audit"]
+    # Edits are compared with the same base: back to the base text, nothing is marked.
+    f = repo / "erd" / "core.txt"
+    f.write_text(OLD)
+    st = f.stat()
+    os.utime(f, ns=(st.st_atime_ns, st.st_mtime_ns + 1_000_000_000))
+    assert poll_once(state)
+    assert not any("diff" in t for t in state.model["tables"])
+    assert state.model["diff"]["added"] == 0 and state.model["diff"]["removed"] == []
+
+
+def test_serve_bad_diff_base_is_a_clean_error(repo, capsys):
+    assert main(["serve", str(repo / "erd"), "--no-open", "--port", "0", "--diff-base", "nope-ref"]) == 2
+    assert "error:" in capsys.readouterr().err

quickdbd_cli-0.1.17/vscode/node_modules/is-it-type/src/index.js

@@ -0,0 +1,169 @@
+/* --------------------
+ * is-it-type module
+ * Entry point
+ * ------------------*/
+
+// Modules
+import getGlobalThis from 'globalthis';
+
+// Exports
+
+/*
+ * Replication of core-util-is methods.
+ * https://www.npmjs.com/package/core-util-is
+ * NB `isBuffer()` is omitted and `isObject()` is different from `core-util-is`'s implementation
+ */
+
+export const {isArray} = Array;
+
+export function isBoolean(arg) {
+	return isType('boolean', arg);
+}
+
+export function isNull(arg) {
+	return arg === null;
+}
+
+export function isUndefined(arg) {
+	return arg === void 0; // eslint-disable-line no-void
+}
+
+export function isNullOrUndefined(arg) {
+	return arg == null;
+}
+
+export function isNumber(arg) {
+	return isType('number', arg);
+}
+
+export function isString(arg) {
+	return isType('string', arg);
+}
+
+export function isSymbol(arg) {
+	return isType('symbol', arg);
+}
+
+export function isRegExp(arg) {
+	return arg instanceof RegExp;
+}
+
+export function isDate(arg) {
+	return arg instanceof Date;
+}
+
+export function isError(arg) {
+	return arg instanceof Error;
+}
+
+export function isFunction(arg) {
+	return isType('function', arg);
+}
+
+export function isPrimitive(arg) {
+	const type = getType(arg);
+	return arg == null
+		|| type === 'boolean'
+		|| type === 'number'
+		|| type === 'string'
+		|| type === 'symbol';
+}
+
+/*
+ * Additional methods
+ */
+
+// Strings
+
+export function isEmptyString(arg) {
+	return arg === '';
+}
+
+export function isFullString(arg) {
+	return isString(arg) && !isEmptyString(arg);
+}
+
+// Objects
+
+const {getPrototypeOf} = Object,
+	ObjectPrototype = Object.prototype,
+	globalThis = getGlobalThis();
+
+export function isObject(arg) {
+	if (!isType('object', arg) || isNull(arg)) return false;
+
+	let proto = getPrototypeOf(arg);
+	if (proto === null || proto === ObjectPrototype) return true;
+
+	while (true) { // eslint-disable-line no-constant-condition
+		const nextProto = getPrototypeOf(proto);
+		if (nextProto === null) return true;
+		if (nextProto === ObjectPrototype) break;
+		proto = nextProto;
+	}
+
+	return isNotNativeProto(proto);
+}
+
+function isNotNativeProto(proto) {
+	let nativeProtos = [];
+	for (const ctorName of [
+		'Function', 'Array', 'Number', 'Boolean', 'String', 'Symbol', 'Date', 'Promise', 'RegExp', 'Error',
+		'ArrayBuffer', 'DataView', 'Map', 'BigInt', 'Set', 'WeakMap', 'WeakSet', 'SharedArrayBuffer',
+		'FinalizationRegistry', 'WeakRef', 'URL', 'URLSearchParams', 'TextEncoder', 'TextDecoder'
+	]) {
+		const ctor = globalThis[ctorName];
+		if (ctor) nativeProtos.push(ctor.prototype);
+	}
+
+	if (typeof Uint8Array === 'function') nativeProtos.push(getPrototypeOf(Uint8Array.prototype));
+
+	if (typeof Set === 'function') {
+		nativeProtos = new Set(nativeProtos);
+		isNotNativeProto = p => !nativeProtos.has(p); // eslint-disable-line no-func-assign
+	} else {
+		isNotNativeProto = p => !nativeProtos.includes(p); // eslint-disable-line no-func-assign
+	}
+
+	return isNotNativeProto(proto);
+}
+
+export function isEmptyObject(arg) {
+	return isObject(arg) && Object.keys(arg).length === 0;
+}
+
+// Numbers
+
+export function isInteger(arg) {
+	return Number.isInteger(arg);
+}
+
+export function isPositiveInteger(arg) {
+	return isInteger(arg) && arg > 0;
+}
+
+export function isPositiveIntegerOrZero(arg) {
+	return isInteger(arg) && arg >= 0;
+}
+
+export function isNegativeInteger(arg) {
+	return isInteger(arg) && arg < 0;
+}
+
+export function isNegativeIntegerOrZero(arg) {
+	return isInteger(arg) && arg <= 0;
+}
+
+// Other
+
+export function isType(type, arg) {
+	return getType(arg) === type;
+}
+
+/*
+ * Helpers
+ */
+
+function getType(arg) {
+	return typeof arg;
+}

quickdbd_cli-0.1.17/vscode/node_modules/ovsx/node_modules/entities/src/decode-codepoint.ts

@@ -0,0 +1,69 @@
+// Adapted from https://github.com/mathiasbynens/he/blob/36afe179392226cf1b6ccdb16ebbb7a5a844d93a/src/he.js#L106-L134
+
+/**
+ * C1 Unicode control character reference replacements (code points 128–159).
+ * Index i gives the replacement for code point 128+i; 0 means "no replacement".
+ */
+const c1: number[] = [
+    8364, 0, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 0,
+    381, 0, 0, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250,
+    339, 0, 382, 376,
+];
+
+/**
+ * True for NUL, UTF-16 surrogates, and values past U+10FFFF.
+ * @param codePoint Unicode code point to check.
+ */
+function isInvalidCodePoint(codePoint: number): boolean {
+    return (
+        codePoint === 0 ||
+        (codePoint >= 0xd8_00 && codePoint <= 0xdf_ff) ||
+        codePoint > 0x10_ff_ff
+    );
+}
+
+/**
+ * Replace the given code point with U+FFFD if it is NUL (0), a surrogate, or
+ * outside the valid Unicode range. Code points in the C1 controls range
+ * (128–159) are remapped to their Windows-1252 equivalents, following the
+ * HTML spec. All other code points are returned unchanged.
+ * @param codePoint Unicode code point to convert.
+ */
+export function replaceCodePoint(codePoint: number): number {
+    if (isInvalidCodePoint(codePoint)) {
+        return 0xff_fd;
+    }
+
+    if (codePoint >= 128 && codePoint <= 159) {
+        return c1[codePoint - 128] || codePoint;
+    }
+
+    return codePoint;
+}
+
+/**
+ * XML numeric character references are the referenced Unicode code point.
+ * Invalid values still become U+FFFD; the HTML Windows-1252 C1 remap is not
+ * applied.
+ * @see https://www.w3.org/TR/xml/#NT-CharRef
+ * @param codePoint Unicode code point to convert.
+ */
+export function replaceCodePointXML(codePoint: number): number {
+    return isInvalidCodePoint(codePoint) ? 0xff_fd : codePoint;
+}
+
+/**
+ * Convert the code point of a decoded numeric entity to a string, replacing
+ * invalid values.
+ *
+ * Fast path for plain BMP code points: [1..0x7F] and [0xA0..0xD7FF] pass
+ * `replaceCodePoint` unchanged (no NUL, C1 remap, surrogate, or out-of-range
+ * handling) and fit a single charCode. 0xd760 = 0xD800 (the first surrogate)
+ * - 0xA0.
+ * @param codePoint Unicode code point to convert.
+ */
+export function codePointToString(codePoint: number): string {
+    return (codePoint - 1) >>> 0 < 0x7f || (codePoint - 0xa0) >>> 0 < 0xd7_60
+        ? String.fromCharCode(codePoint)
+        : String.fromCodePoint(replaceCodePoint(codePoint));
+}