queryview 0.0.2__tar.gz

queryview-0.0.2/.claude/settings.json

@@ -0,0 +1,23 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx vitest *)",
+      "Bash(npx tsc *)",
+      "Bash(npx eslint *)",
+      "mcp__plugin_devpowers_github__pull_request_read",
+      "mcp__plugin_devpowers_github__list_pull_requests",
+      "mcp__plugin_devpowers_github__get_job_logs"
+    ]
+  },
+  "extraKnownMarketplaces": {
+    "devpowers": {
+      "source": {
+        "source": "github",
+        "repo": "kolodkin/devpowers"
+      }
+    }
+  },
+  "enabledPlugins": {
+    "devpowers@devpowers": true
+  }
+}

queryview-0.0.2/.github/actions/start-git-daemon/action.yaml

@@ -0,0 +1,31 @@
+name: Start git daemon
+description: >-
+  Start a loopback `git daemon` that serves — and accepts pushes into — bare
+  repos under a base path, so e2e tests exercise git sync against a real
+  git:// remote with no auth. Creates an empty bare repo and exports
+  GIT_SYNC_REMOTE pointing at it; `--detach` keeps the daemon alive across
+  steps.
+
+runs:
+  using: composite
+  steps:
+    - name: Start git daemon
+      shell: bash
+      run: |
+        GIT_DAEMON_BASE="$RUNNER_TEMP/gitsrv"
+        mkdir -p "$GIT_DAEMON_BASE"
+        git init --bare -b main "$GIT_DAEMON_BASE/queryview.git"
+        echo "GIT_SYNC_REMOTE=git://127.0.0.1:9418/queryview.git" >> "$GITHUB_ENV"
+        git daemon --reuseaddr --listen=127.0.0.1 --port=9418 \
+          --base-path="$GIT_DAEMON_BASE" --export-all \
+          --enable=receive-pack --detach
+        for i in $(seq 1 30); do
+          if (exec 3<>/dev/tcp/127.0.0.1/9418) 2>/dev/null; then
+            exec 3>&-
+            echo "git daemon is ready"
+            exit 0
+          fi
+          sleep 1
+        done
+        echo "git daemon failed to become ready" >&2
+        exit 1

queryview-0.0.2/.github/workflows/ci.yml

@@ -0,0 +1,182 @@
+name: CI
+
+on:
+  workflow_dispatch:
+  pull_request:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_RUNNER_NODE_VERSION: node24
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      # pre-commit's pyright hook resolves imports from the project's .venv
+      # (see pyrightconfig.json), so sync it first.
+      - name: Install backend + test dependencies
+        run: uv sync --frozen --group test
+
+      - name: Run pre-commit
+        uses: pre-commit/action@v3.0.1
+
+  test-backend:
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Install backend + test dependencies
+        run: uv sync --frozen --group test
+
+      - name: Run backend unit tests
+        run: uv run --frozen pytest backend/queryview
+
+  test-e2e:
+    runs-on: ubuntu-latest
+    environment: CICD
+    permissions:
+      contents: write
+      checks: write
+    services:
+      clickhouse:
+        image: clickhouse/clickhouse-server:24
+        ports:
+          - 8123:8123
+        # Probe the HTTP interface (8123) — what the backend actually uses —
+        # so the readiness gate matches the app.
+        options: >-
+          --health-cmd "wget --spider -q localhost:8123/ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+          --add-host=host.docker.internal:host-gateway
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: package-lock.json
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Install backend + test dependencies
+        run: uv sync --frozen --group test
+
+      - name: Install frontend dependencies
+        run: npm ci
+
+      - name: Install Playwright browser
+        run: uv run --frozen --group test playwright install --with-deps chromium
+
+      - name: Build frontend
+        run: npm run build -w frontend
+
+      - name: Start git daemon
+        uses: ./.github/actions/start-git-daemon
+
+      - name: Start backend (serving built SPA)
+        run: |
+          SERVE_STATIC=1 uv run --frozen queryview-backend > backend.log 2>&1 &
+          echo $! > backend.pid
+          for i in $(seq 1 30); do
+            if curl -sf http://localhost:8000/api/health > /dev/null; then
+              echo "Backend is up"; exit 0
+            fi
+            sleep 1
+          done
+          echo "Backend failed to start"; cat backend.log; exit 1
+
+      - name: Run Playwright e2e tests
+        id: e2e
+        env:
+          BASE_URL: http://localhost:8000
+        run: |
+          uv run --frozen --group test pytest e2e \
+            --tracing retain-on-failure \
+            --output test-results \
+            --html=report/index.html --self-contained-html
+
+      - name: Stop backend
+        if: always()
+        run: |
+          if [ -f backend.pid ]; then
+            kill "$(cat backend.pid)" 2>/dev/null || true
+          fi
+
+      - name: Upload trace artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-traces
+          path: test-results/
+          retention-days: 1
+          if-no-files-found: ignore
+
+      - name: Check if report exists
+        id: check-report
+        if: always()
+        run: |
+          if [ -f "report/index.html" ]; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+            echo "E2E report is present"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+            echo "E2E report missing"
+          fi
+
+      - name: Deploy E2E Report
+        if: always() && steps.check-report.outputs.exists == 'true'
+        # Publishing to the external artifact-view repo needs DEPLOY_KEY; don't
+        # fail the PR check when that publish can't run — the step still surfaces
+        # the error as a warning annotation.
+        continue-on-error: true
+        uses: peaceiris/actions-gh-pages@v4
+        with:
+          deploy_key: ${{ secrets.DEPLOY_KEY }}
+          external_repository: kolodkin/artifact-view
+          publish_dir: ./report
+          destination_dir: queryview-/e2e-report/${{ github.run_number }}
+          publish_branch: gh-pages
+          keep_files: true
+
+      - name: Create E2E Report check
+        if: always()
+        uses: LouisBrunner/checks-action@v2.0.0
+        env:
+          REPORT_URL: https://${{ github.repository_owner }}.github.io/artifact-view/queryview-/e2e-report/${{ github.run_number }}
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          name: E2E Report
+          conclusion: ${{ steps.e2e.outcome }}
+          details_url: ${{ env.REPORT_URL }}
+          output: |
+            {"title":"${{ steps.e2e.outcome == 'success' && 'Tests passed' || 'Tests failed' }}","summary":"**[View Full E2E Report](${{ env.REPORT_URL }})**"}

queryview-0.0.2/.github/workflows/publish.yaml

@@ -0,0 +1,443 @@
+name: Publish to PyPI
+
+# Simpler analog of aaiclick's publish.yaml: build the SPA into the wheel,
+# smoke-test the installed package, then publish via PyPI trusted publishing
+# and cut a GitHub release. Like aaiclick, a multi-arch container image is
+# built from the release wheel, pushed to GHCR as an rc tag, smoke-tested,
+# and promoted (same digests) to vX.Y.Z / latest after publish. Repeated
+# steps are YAML-anchored at first use and aliased below.
+
+on:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: "Release tag (must match vX.Y.Z)"
+        required: true
+        type: string
+      pre-release:
+        description: "Mark as pre-release on GitHub"
+        required: false
+        type: boolean
+        default: false
+      skip-e2e:
+        description: "Skip the Playwright e2e release gate (emergency only)"
+        required: false
+        type: boolean
+        default: false
+
+env:
+  FORCE_JAVASCRIPT_ACTIONS_RUNNER_NODE_VERSION: node24
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Validate tag format
+        run: |
+          if ! echo "${{ inputs.tag }}" | grep -Eq '^v[0-9]+\.[0-9]+\.[0-9]+$'; then
+            echo "Error: tag '${{ inputs.tag }}' does not match vX.Y.Z"
+            exit 1
+          fi
+
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Setup Node
+        uses: actions/setup-node@v4
+        with:
+          node-version: 22
+          cache: npm
+          cache-dependency-path: package-lock.json
+
+      - name: Build SPA bundle
+        run: |
+          npm ci
+          npm run build -w frontend
+          test -f frontend/dist/index.html \
+            || { echo "Vite build did not produce frontend/dist/index.html"; exit 1; }
+
+      - name: Build package (SPA bundled as queryview/static)
+        run: |
+          cp -r frontend/dist backend/queryview/static
+          VERSION="${{ inputs.tag }}"
+          SETUPTOOLS_SCM_PRETEND_VERSION="${VERSION#v}" uv build
+
+      - name: Verify wheel contains SPA bundle
+        run: |
+          wheel=$(ls dist/queryview-*.whl | head -n 1)
+          unzip -l "$wheel" | grep -q "queryview/static/index.html" \
+            || { echo "Built wheel $wheel does not contain queryview/static/index.html"; exit 1; }
+
+      - name: Upload dist artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Export pinned test dependencies
+        run: uv export --frozen --group test --no-emit-project -o requirements-test.txt
+
+      - name: Upload requirements artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: requirements
+          path: requirements-test.txt
+
+  build-rc-image:
+    needs: build
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 30
+    permissions:
+      contents: read
+      packages: write
+    strategy:
+      fail-fast: true
+      matrix:
+        include:
+          - platform: amd64
+            runner: ubuntu-latest
+          - platform: arm64
+            runner: ubuntu-24.04-arm
+    env:
+      IMAGE: ghcr.io/kolodkin/queryview
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      # The image pip-installs queryview==<version>. The wheel is not on PyPI
+      # yet (publish is gated on this very image), so serve the artifact from
+      # a local pypiserver; it redirects unknown packages to pypi.org, so
+      # dependencies resolve through the same index URL.
+      - name: Serve wheel via local pypiserver
+        run: |
+          docker run -d --name pypiserver -p 8080:8080 \
+            pypiserver/pypiserver:v2.3.2 run -p 8080 -a . -P . --server gunicorn
+          for i in $(seq 1 30); do
+            curl -fsS http://localhost:8080/simple/ >/dev/null 2>&1 && break
+            if [ "$i" -eq 30 ]; then
+              echo "pypiserver did not come up in time" >&2
+              exit 1
+            fi
+            sleep 2
+          done
+          for f in dist/*.whl dist/*.tar.gz; do
+            curl -fsSL -F "content=@${f}" -F ":action=file_upload" http://localhost:8080/
+          done
+
+      - &ghcr-login
+        name: Log in to GHCR
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Native per-arch builds (no QEMU). --network=host lets the build reach
+      # the pypiserver on localhost; pip trusts localhost for plain HTTP.
+      - name: Build & push per-arch rc image
+        run: |
+          VERSION="${{ inputs.tag }}"
+          PEP440="${VERSION#v}"
+          ARCH_TAG="${VERSION}-rc-${{ matrix.platform }}"
+          docker build --network=host -f docker/Dockerfile \
+            --build-arg QUERYVIEW_VERSION="${PEP440}" \
+            --build-arg PIP_INDEX_URL="http://localhost:8080/simple/" \
+            -t "${IMAGE}:${ARCH_TAG}" .
+          docker push "${IMAGE}:${ARCH_TAG}"
+
+  merge-rc-image:
+    needs: build-rc-image
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - *ghcr-login
+
+      - name: Assemble multi-arch rc manifest
+        run: |
+          REF="ghcr.io/kolodkin/queryview"
+          TAG="${{ inputs.tag }}-rc"
+          docker buildx imagetools create -t "${REF}:${TAG}" \
+            "${REF}:${TAG}-amd64" "${REF}:${TAG}-arm64"
+
+  # Run the exact rc image that will be promoted and verify the containerized
+  # server comes up: /api/health, the bundled SPA at /, and the index.html
+  # fallback for client-side routes.
+  test-image:
+    needs: merge-rc-image
+    runs-on: ubuntu-latest
+    permissions:
+      packages: read
+    steps:
+      - *ghcr-login
+
+      - name: Smoke-test rc image
+        run: |
+          docker run -d --name queryview -p 8000:8000 \
+            "ghcr.io/kolodkin/queryview:${{ inputs.tag }}-rc"
+          for i in $(seq 1 30); do
+            curl -sf http://localhost:8000/api/health > /dev/null && break
+            if [ "$i" -eq 30 ]; then
+              echo "Server failed to start"; docker logs queryview; exit 1
+            fi
+            sleep 1
+          done
+          curl -sf http://localhost:8000/ | grep -q "<!doctype html>" \
+            || { echo "/ did not serve the bundled SPA"; docker logs queryview; exit 1; }
+          test "$(curl -sf -o /dev/null -w '%{http_code}' http://localhost:8000/some/client/route)" = "200" \
+            || { echo "SPA fallback route did not return 200"; docker logs queryview; exit 1; }
+          docker rm -f queryview
+
+  # Install the built wheel into a clean venv (no repo checkout) and verify the
+  # packaged server comes up: /api/health, the bundled SPA at /, and the
+  # index.html fallback for client-side routes.
+  test-package:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Install built wheel
+        run: |
+          uv venv --python 3.11
+          uv pip install dist/queryview-*.whl
+
+      - name: Smoke-test installed package
+        working-directory: ${{ runner.temp }}
+        run: |
+          DB_PATH="$PWD/queryview.db" "$GITHUB_WORKSPACE/.venv/bin/queryview" > server.log 2>&1 &
+          pid=$!
+          for i in $(seq 1 30); do
+            curl -sf http://localhost:8000/api/health > /dev/null && break
+            if [ "$i" -eq 30 ]; then
+              echo "Server failed to start"; cat server.log; exit 1
+            fi
+            sleep 1
+          done
+          curl -sf http://localhost:8000/ | grep -q "<!doctype html>" \
+            || { echo "/ did not serve the bundled SPA"; cat server.log; exit 1; }
+          test "$(curl -sf -o /dev/null -w '%{http_code}' http://localhost:8000/some/client/route)" = "200" \
+            || { echo "SPA fallback route did not return 200"; cat server.log; exit 1; }
+          kill "$pid"
+
+  # Run the packaged backend test suite against the installed wheel. No
+  # checkout — the tests ship inside the queryview package, so this exercises
+  # exactly the bits users install.
+  test-package-pytest:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Create virtual environment
+        run: uv venv --python 3.11
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Download requirements artifact
+        uses: actions/download-artifact@v4
+        with:
+          name: requirements
+
+      - name: Install pinned dependencies and built wheel
+        run: |
+          uv pip install -r requirements-test.txt
+          uv pip install --no-deps --no-index --find-links dist/ queryview
+
+      - name: Run packaged tests against the installed wheel
+        working-directory: ${{ runner.temp }}
+        env:
+          VIRTUAL_ENV: ${{ github.workspace }}/.venv
+        run: uv run --no-project pytest --pyargs queryview
+
+  # Playwright e2e against the installed wheel: server and SPA are the exact
+  # bytes being published (no Node/frontend build — the wheel ships the SPA).
+  # The checkout supplies only e2e/, uv.lock, and the git-daemon action.
+  # Runs after the packaged pytest gate so the expensive leg starts only once
+  # the cheap one passes.
+  test-package-e2e:
+    needs: [build, test-package-pytest]
+    if: ${{ !inputs.skip-e2e }}
+    runs-on: ubuntu-latest
+    services:
+      clickhouse:
+        image: clickhouse/clickhouse-server:24
+        ports:
+          - 8123:8123
+        # Probe the HTTP interface (8123) — what the backend actually uses —
+        # so the readiness gate matches the app.
+        options: >-
+          --health-cmd "wget --spider -q localhost:8123/ping"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+          --add-host=host.docker.internal:host-gateway
+      postgres:
+        image: postgres:16
+        env:
+          POSTGRES_PASSWORD: postgres
+          POSTGRES_HOST_AUTH_METHOD: trust
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd "pg_isready -U postgres"
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Setup uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Install test dependencies (project not installed)
+        run: uv sync --frozen --group test --no-install-project
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Install built wheel
+        run: uv pip install --no-deps dist/queryview-*.whl
+
+      - name: Install Playwright browser
+        run: uv run --no-sync playwright install --with-deps chromium
+
+      - name: Start git daemon
+        uses: ./.github/actions/start-git-daemon
+
+      - name: Start backend from the installed wheel
+        run: |
+          SERVE_STATIC=1 .venv/bin/queryview > backend.log 2>&1 &
+          echo $! > backend.pid
+          for i in $(seq 1 30); do
+            if curl -sf http://localhost:8000/api/health > /dev/null; then
+              echo "Backend is up"; exit 0
+            fi
+            sleep 1
+          done
+          echo "Backend failed to start"; cat backend.log; exit 1
+
+      - name: Run Playwright e2e tests
+        env:
+          BASE_URL: http://localhost:8000
+        run: |
+          uv run --no-sync pytest e2e \
+            --tracing retain-on-failure \
+            --output test-results
+
+      - name: Stop backend
+        if: always()
+        run: |
+          if [ -f backend.pid ]; then
+            kill "$(cat backend.pid)" 2>/dev/null || true
+          fi
+
+      - name: Upload trace artifacts
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: playwright-traces-release
+          path: test-results/
+          retention-days: 1
+          if-no-files-found: ignore
+
+  publish:
+    needs: [test-package, test-package-pytest, test-package-e2e, test-image]
+    if: >-
+      always()
+      && needs.test-package.result == 'success'
+      && needs.test-package-pytest.result == 'success'
+      && needs.test-image.result == 'success'
+      && (needs.test-package-e2e.result == 'success'
+          || needs.test-package-e2e.result == 'skipped')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Download dist artifacts
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Create and push tag
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          git tag ${{ inputs.tag }}
+          git push origin ${{ inputs.tag }}
+
+      - name: Create GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release create ${{ inputs.tag }} dist/* \
+            --title "${{ inputs.tag }}" \
+            --generate-notes \
+            ${{ inputs.pre-release && '--prerelease' || '' }}
+
+  promote-image:
+    needs: [publish]
+    runs-on: ubuntu-latest
+    permissions:
+      packages: write
+    steps:
+      - *ghcr-login
+
+      # Retag the exact multi-arch manifest the smoke gate tested — no
+      # rebuild, no wait-for-PyPI. Tested digests ARE the published digests.
+      - name: Promote rc manifest
+        run: |
+          REF="ghcr.io/kolodkin/queryview"
+          TAGS=(-t "${REF}:${{ inputs.tag }}")
+          if [ "${{ inputs.pre-release }}" != "true" ]; then
+            TAGS+=(-t "${REF}:latest")
+          fi
+          docker buildx imagetools create "${TAGS[@]}" "${REF}:${{ inputs.tag }}-rc"
+
+      # Best-effort: GITHUB_TOKEN may lack package-version delete rights;
+      # leftover -rc tags are harmless and useful for debugging.
+      - name: Clean up rc tags
+        continue-on-error: true
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          for suffix in rc rc-amd64 rc-arm64; do
+            TAG="${{ inputs.tag }}-${suffix}"
+            VERSION_ID=$(gh api "/user/packages/container/queryview/versions" --paginate \
+              --jq ".[] | select(.metadata.container.tags[]? == \"${TAG}\") | .id" | head -n1)
+            if [ -n "$VERSION_ID" ]; then
+              gh api -X DELETE "/user/packages/container/queryview/versions/${VERSION_ID}" || true
+            fi
+          done