Work with latest Cloud Run, python:3.14-slim-trixie base image

Refs #2511

.github/workflows/deploy-branch-preview.yml

@@ -0,0 +1,35 @@
+name: Deploy a Datasette branch preview to Vercel
+
+on:
+  workflow_dispatch:
+    inputs:
+      branch:
+        description: "Branch to deploy"
+        required: true
+        type: string
+
+jobs:
+  deploy-branch-preview:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - name: Set up Python 3.11
+      uses: actions/setup-python@v6
+      with:
+        python-version: "3.11"
+    - name: Install dependencies
+      run: |
+        pip install datasette-publish-vercel
+    - name: Deploy the preview
+      env:
+        VERCEL_TOKEN: ${{ secrets.BRANCH_PREVIEW_VERCEL_TOKEN }}
+      run: |
+        export BRANCH="${{ github.event.inputs.branch }}"
+        wget https://latest.datasette.io/fixtures.db
+        datasette publish vercel fixtures.db \
+          --branch $BRANCH \
+          --project "datasette-preview-$BRANCH" \
+          --token $VERCEL_TOKEN \
+          --scope datasette \
+          --about "Preview of $BRANCH" \
+          --about_url "https://github.com/simonw/datasette/tree/$BRANCH"

.github/workflows/deploy-latest.yml

@@ -1,11 +1,10 @@
 name: Deploy latest.datasette.io
 
 on:
-  workflow_dispatch:
   push:
     branches:
     - main
-    #   - 1.0-dev
+    - cloudrun-fix
 
 permissions:
   contents: read
@@ -15,16 +14,24 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Check out datasette
-      uses: actions/checkout@v6
+      uses: actions/checkout@v3
     - name: Set up Python
       uses: actions/setup-python@v6
+      # Using Python 3.10 for gcloud compatibility:
       with:
-        python-version: "3.13"
-        cache: pip
+        python-version: "3.10"
+    - uses: actions/cache@v4
+      name: Configure pip caching
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/setup.py') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
     - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install . --group dev
+        python -m pip install -e .[test]
+        python -m pip install -e .[docs]
         python -m pip install sphinx-to-sqlite==0.1a1
     - name: Run tests
       if: ${{ github.ref == 'refs/heads/main' }}
@@ -57,7 +64,7 @@ jobs:
             db.route = "alternative-route"
         ' > plugins/alternative_route.py
         cp fixtures.db fixtures2.db
-    - name: And the counters writable stored query demo
+    - name: And the counters writable canned query demo
       run: |
         cat > plugins/counters.py <<EOF
         from datasette import hookimpl
@@ -69,24 +76,23 @@ jobs:
                 await db.execute_write("insert or ignore into counters (name, value) values ('counter_a', 0)")
                 await db.execute_write("insert or ignore into counters (name, value) values ('counter_b', 0)")
                 await db.execute_write("insert or ignore into counters (name, value) values ('counter_c', 0)")
-                for name in ("counter_a", "counter_b", "counter_c"):
-                    await datasette.add_query(
-                        "counters",
-                        "increment_{}".format(name),
-                        "update counters set value = value + 1 where name = '{}'".format(name),
-                        on_success_message_sql="select 'Counter {name} incremented to ' || value from counters where name = '{name}'".format(name=name),
-                        is_write=True,
-                        is_trusted=True,
-                    )
-                    await datasette.add_query(
-                        "counters",
-                        "decrement_{}".format(name),
-                        "update counters set value = value - 1 where name = '{}'".format(name),
-                        on_success_message_sql="select 'Counter {name} decremented to ' || value from counters where name = '{name}'".format(name=name),
-                        is_write=True,
-                        is_trusted=True,
-                    )
             return inner
+        @hookimpl
+        def canned_queries(database):
+            if database == "counters":
+                queries = {}
+                for name in ("counter_a", "counter_b", "counter_c"):
+                    queries["increment_{}".format(name)] = {
+                        "sql": "update counters set value = value + 1 where name = '{}'".format(name),
+                        "on_success_message_sql": "select 'Counter {name} incremented to ' || value from counters where name = '{name}'".format(name=name),
+                        "write": True,
+                    }
+                    queries["decrement_{}".format(name)] = {
+                        "sql": "update counters set value = value - 1 where name = '{}'".format(name),
+                        "on_success_message_sql": "select 'Counter {name} decremented to ' || value from counters where name = '{name}'".format(name=name),
+                        "write": True,
+                    }
+                return queries
         EOF
     # - name: Make some modifications to metadata.json
     #   run: |
@@ -97,7 +103,7 @@ jobs:
     #     cat metadata.json
     - id: auth
       name: Authenticate to Google Cloud
-      uses: google-github-actions/auth@v3
+      uses: google-github-actions/auth@v2
       with:
         credentials_json: ${{ secrets.GCP_SA_KEY }}
     - name: Set up Cloud SDK
@@ -117,7 +123,7 @@ jobs:
             --plugins-dir=plugins \
             --branch=$GITHUB_SHA \
             --version-note=$GITHUB_SHA \
-            --extra-options="--setting template_debug 1 --setting trace_debug 1 --crossdb --root" \
+            --extra-options="--setting template_debug 1 --setting trace_debug 1 --crossdb" \
             --install 'datasette-ephemeral-tables>=0.2.2' \
             --service "datasette-latest$SUFFIX" \
             --secret $LATEST_DATASETTE_SECRET

.github/workflows/documentation-links.yml

@@ -1,6 +1,6 @@
 name: Read the Docs Pull Request Preview
 on:
-  pull_request:
+  pull_request_target:
     types:
       - opened
 

.github/workflows/prettier.yml

@@ -10,8 +10,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Check out repo
-      uses: actions/checkout@v6
-    - uses: actions/cache@v5
+      uses: actions/checkout@v4
+    - uses: actions/cache@v4
       name: Configure npm caching
       with:
         path: ~/.npm

.github/workflows/publish.yml

@@ -14,16 +14,16 @@ jobs:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         cache: pip
-        cache-dependency-path: pyproject.toml
+        cache-dependency-path: setup.py
     - name: Install dependencies
       run: |
-        pip install . --group dev
+        pip install -e '.[test]'
     - name: Run tests
       run: |
         pytest
@@ -35,13 +35,13 @@ jobs:
     permissions:
       id-token: write
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python
       uses: actions/setup-python@v6
       with:
         python-version: '3.13'
         cache: pip
-        cache-dependency-path: pyproject.toml
+        cache-dependency-path: setup.py
     - name: Install dependencies
       run: |
         pip install setuptools wheel build
@@ -56,16 +56,16 @@ jobs:
     needs: [deploy]
     if: "!github.event.release.prerelease"
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python
       uses: actions/setup-python@v6
       with:
         python-version: '3.10'
         cache: pip
-        cache-dependency-path: pyproject.toml
+        cache-dependency-path: setup.py
     - name: Install dependencies
       run: |
-        python -m pip install . --group dev
+        python -m pip install -e .[docs]
         python -m pip install sphinx-to-sqlite==0.1a1
     - name: Build docs.db
       run: |-
@@ -92,7 +92,7 @@ jobs:
     needs: [deploy]
     if: "!github.event.release.prerelease"
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Build and push to Docker Hub
       env:
         DOCKER_USER: ${{ secrets.DOCKER_USER }}

.github/workflows/push_docker_tag.yml

@@ -13,7 +13,7 @@ jobs:
   deploy_docker:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v2
     - name: Build and push to Docker Hub
       env:
         DOCKER_USER: ${{ secrets.DOCKER_USER }}

.github/workflows/spellcheck.yml

@@ -9,16 +9,16 @@ jobs:
   spellcheck:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python
       uses: actions/setup-python@v6
       with:
         python-version: '3.11'
         cache: 'pip'
-        cache-dependency-path: '**/pyproject.toml'
+        cache-dependency-path: '**/setup.py'
     - name: Install dependencies
       run: |
-        pip install . --group dev
+        pip install -e '.[docs]'
     - name: Check spelling
       run: |
         codespell README.md --ignore-words docs/codespell-ignore-words.txt

.github/workflows/stable-docs.yml

@@ -1,76 +0,0 @@
-name: Update Stable Docs
-
-on:
-  release:
-    types: [published]
-  push:
-    branches:
-    - main
-
-permissions:
-  contents: write
-
-jobs:
-  update_stable_docs:
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v6
-      with:
-        fetch-depth: 0  # We need all commits to find docs/ changes
-    - name: Set up Git user
-      run: |
-        git config user.name "Automated"
-        git config user.email "actions@users.noreply.github.com"
-    - name: Create stable branch if it does not yet exist
-      run: |
-        if ! git ls-remote --heads origin stable | grep -qE '\bstable\b'; then
-          # Make sure we have all tags locally
-          git fetch --tags --quiet
-
-          # Latest tag that is just numbers and dots (optionally prefixed with 'v')
-          # e.g., 0.65.2 or v0.65.2 — excludes 1.0a20, 1.0-rc1, etc.
-          LATEST_RELEASE=$(
-            git tag -l --sort=-v:refname \
-            | grep -E '^v?[0-9]+(\.[0-9]+){1,3}$' \
-            | head -n1
-          )
-
-          git checkout -b stable
-
-          # If there are any stable releases, copy docs/ from the most recent
-          if [ -n "$LATEST_RELEASE" ]; then
-            rm -rf docs/
-            git checkout "$LATEST_RELEASE" -- docs/ || true
-          fi
-
-          git commit -m "Populate docs/ from $LATEST_RELEASE" || echo "No changes"
-          git push -u origin stable
-        fi
-    - name: Handle Release
-      if: github.event_name == 'release' && !github.event.release.prerelease
-      run: |
-        git fetch --all
-        git checkout stable
-        git reset --hard ${GITHUB_REF#refs/tags/}
-        git push origin stable --force
-    - name: Handle Commit to Main
-      if: contains(github.event.head_commit.message, '!stable-docs')
-      run: |
-        git fetch origin
-        git checkout -b stable origin/stable
-        # Get the list of modified files in docs/ from the current commit
-        FILES=$(git diff-tree --no-commit-id --name-only -r ${{ github.sha }} -- docs/)
-        # Check if the list of files is non-empty
-        if [[ -n "$FILES" ]]; then
-          # Checkout those files to the stable branch to over-write with their contents
-          for FILE in $FILES; do
-            git checkout ${{ github.sha }} -- $FILE
-          done
-          git add docs/
-          git commit -m "Doc changes from ${{ github.sha }}"
-          git push origin stable
-        else
-          echo "No changes to docs/ in this commit."
-          exit 0
-        fi

.github/workflows/test-coverage.yml

@@ -15,17 +15,17 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - name: Check out datasette
-      uses: actions/checkout@v6
+      uses: actions/checkout@v4
     - name: Set up Python
       uses: actions/setup-python@v6
       with:
         python-version: '3.12'
         cache: 'pip'
-        cache-dependency-path: '**/pyproject.toml'
+        cache-dependency-path: '**/setup.py'
     - name: Install Python dependencies
       run: |
         python -m pip install --upgrade pip
-        python -m pip install . --group dev
+        python -m pip install -e .[test]
         python -m pip install pytest-cov
     - name: Run tests
       run: |-

.github/workflows/test-pyodide.yml

@@ -12,15 +12,15 @@ jobs:
   test:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python 3.10
       uses: actions/setup-python@v6
       with:
         python-version: "3.10"
         cache: 'pip'
-        cache-dependency-path: '**/pyproject.toml'
+        cache-dependency-path: '**/setup.py'
     - name: Cache Playwright browsers
-      uses: actions/cache@v5
+      uses: actions/cache@v4
       with:
         path: ~/.cache/ms-playwright/
         key: ${{ runner.os }}-browsers

.github/workflows/test-sqlite-support.yml

@@ -25,14 +25,14 @@ jobs:
           #"3.23.1" # 2018-04-10, before UPSERT
         ]
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true
         cache: pip
-        cache-dependency-path: pyproject.toml
+        cache-dependency-path: setup.py
     - name: Set up SQLite ${{ matrix.sqlite-version }}
       uses: asg017/sqlite-versions@71ea0de37ae739c33e447af91ba71dda8fcf22e6
       with:
@@ -45,7 +45,7 @@ jobs:
         (cd tests && gcc ext.c -fPIC -shared -o ext.so)
     - name: Install dependencies
       run: |
-        pip install . --group dev
+        pip install -e '.[test]'
         pip freeze
     - name: Run tests
       run: |

.github/workflows/test.yml

@@ -12,20 +12,20 @@ jobs:
       matrix:
         python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v4
     - name: Set up Python ${{ matrix.python-version }}
       uses: actions/setup-python@v6
       with:
         python-version: ${{ matrix.python-version }}
         allow-prereleases: true
         cache: pip
-        cache-dependency-path: pyproject.toml
+        cache-dependency-path: setup.py
     - name: Build extension for --load-extension test
       run: |-
         (cd tests && gcc ext.c -fPIC -shared -o ext.so)
     - name: Install dependencies
       run: |
-        pip install . --group dev
+        pip install -e '.[test]'
         pip freeze
     - name: Run tests
       run: |
@@ -33,12 +33,9 @@ jobs:
         pytest -m "serial"
         # And the test that exceeds a localhost HTTPS server
         tests/test_datasette_https_server.sh
-    - name: Black
+    - name: Install docs dependencies
       run: |
-        black --version
-        black --check .
-    - name: Ruff
-      run: ruff check datasette tests
+        pip install -e '.[docs]'
     - name: Check if cog needs to be run
       run: |
         cog --check docs/*.rst

.github/workflows/tmate-mac.yml

@@ -10,6 +10,6 @@ jobs:
   build:
     runs-on: macos-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v2
     - name: Setup tmate session
       uses: mxschmitt/action-tmate@v3

.github/workflows/tmate.yml

@@ -5,14 +5,11 @@ on:
 
 permissions:
   contents: read
-  models: read
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v6
+    - uses: actions/checkout@v2
     - name: Setup tmate session
       uses: mxschmitt/action-tmate@v3
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -5,12 +5,6 @@ scratchpad
 
 .vscode
 
-uv.lock
-data.db
-
-# test databases
-*.db
-
 # We don't use Pipfile, so ignore them
 Pipfile
 Pipfile.lock
@@ -129,6 +123,4 @@ node_modules
 # include it in source control.
 tests/*.dylib
 tests/*.so
-tests/*.dll
-
-.idea
+tests/*.dll

.readthedocs.yaml

@@ -1,17 +1,16 @@
 version: 2
 
-sphinx:
-  configuration: docs/conf.py
-
 build:
-  os: ubuntu-24.04
+  os: ubuntu-20.04
   tools:
-    python: "3.13"
-  jobs:
-    install:
-    - pip install --upgrade pip
-    - pip install . --group dev
+    python: "3.11"
 
-formats:
-- pdf
-- epub
+sphinx:
+   configuration: docs/conf.py
+
+python:
+  install:
+  - method: pip
+    path: .
+    extra_requirements:
+    - docs

Dockerfile

@@ -1,4 +1,4 @@
-FROM python:3.11.0-slim-bullseye as build
+FROM python:3.14-slim-trixie as build
 
 # Version of Datasette to install, e.g. 0.55
 #   docker build . -t datasette --build-arg VERSION=0.55

Justfile

@@ -5,56 +5,38 @@ export DATASETTE_SECRET := "not_a_secret"
 
 # Setup project
 @init:
-  uv sync
+  pipenv run pip install -e '.[test,docs]'
 
 # Run pytest with supplied options
-@test *options: init
-  uv run pytest -n auto {{options}}
+@test *options:
+  pipenv run pytest {{options}}
 
 @codespell:
-  uv run codespell README.md --ignore-words docs/codespell-ignore-words.txt
-  uv run codespell docs/*.rst --ignore-words docs/codespell-ignore-words.txt
-  uv run codespell datasette -S datasette/static --ignore-words docs/codespell-ignore-words.txt
-  uv run codespell tests --ignore-words docs/codespell-ignore-words.txt
+  pipenv run codespell README.md --ignore-words docs/codespell-ignore-words.txt
+  pipenv run codespell docs/*.rst --ignore-words docs/codespell-ignore-words.txt
+  pipenv run codespell datasette -S datasette/static --ignore-words docs/codespell-ignore-words.txt
+  pipenv run codespell tests --ignore-words docs/codespell-ignore-words.txt
 
-# Run linters: black, ruff, cog
+# Run linters: black, flake8, mypy, cog
 @lint: codespell
-  uv run black datasette tests --check
-  uv run ruff check datasette tests
-  uv run cog --check README.md docs/*.rst
-
-# Apply ruff fixes
-@fix:
-  uv run ruff check --fix datasette tests
+  pipenv run black . --check
+  pipenv run flake8
+  pipenv run cog --check README.md docs/*.rst
 
 # Rebuild docs with cog
 @cog:
-  uv run cog -r README.md docs/*.rst
+  pipenv run cog -r README.md docs/*.rst
 
 # Serve live docs on localhost:8000
-@docs: cog blacken-docs
-  uv run make -C docs livehtml
-
-# Build docs as static HTML
-@docs-build: cog blacken-docs
-  rm -rf docs/_build && cd docs && uv run make html
+@docs: cog
+  pipenv run blacken-docs -l 60 docs/*.rst
+  cd docs && pipenv run make livehtml
 
 # Apply Black
 @black:
-  uv run black datasette tests
+  pipenv run black .
 
-# Apply blacken-docs
-@blacken-docs:
-  uv run blacken-docs -l 60 docs/*.rst
-
-# Apply prettier
-@prettier:
-  npm run fix
-
-# Format code with both black and prettier
-@format: black prettier blacken-docs
-
-@serve *options:
-  uv run sqlite-utils create-database data.db
-  uv run sqlite-utils create-table data.db docs id integer title text --pk id --ignore
-  uv run python -m datasette data.db --root --reload {{options}}
+@serve:
+  pipenv run sqlite-utils create-database data.db
+  pipenv run sqlite-utils create-table data.db docs id integer title text --pk id --ignore
+  pipenv run python -m datasette data.db --root --reload

datasette/__init__.py

@@ -1,7 +1,6 @@
 from datasette.permissions import Permission  # noqa
 from datasette.version import __version_info__, __version__  # noqa
 from datasette.events import Event  # noqa
-from datasette.tokens import TokenHandler, TokenRestrictions  # noqa
 from datasette.utils.asgi import Forbidden, NotFound, Request, Response  # noqa
 from datasette.utils import actor_matches_allow  # noqa
 from datasette.views import Context  # noqa

datasette/_pytest_plugin.py

@@ -1,108 +0,0 @@
-"""
-Pytest plugin that automatically closes any Datasette instances constructed
-during a pytest test — both in the test body and in function-scoped
-fixtures. Instances constructed by session-, module-, class- or package-
-scoped fixtures are left alone, because other tests in the session will
-still want to use them.
-
-Registered as a pytest11 entry point in pyproject.toml so that downstream
-projects using Datasette get the same FD-safety net for their own tests.
-
-Opt out by setting ``datasette_autoclose = false`` in pytest.ini (or the
-equivalent ini file).
-"""
-
-from __future__ import annotations
-
-import contextvars
-import weakref
-
-import pytest
-
-from datasette.app import Datasette
-
-_active_instances: contextvars.ContextVar[list | None] = contextvars.ContextVar(
-    "datasette_active_instances", default=None
-)
-
-_original_init = Datasette.__init__
-
-
-def _tracking_init(self, *args, **kwargs):
-    _original_init(self, *args, **kwargs)
-    instances = _active_instances.get()
-    if instances is not None:
-        instances.append(weakref.ref(self))
-
-
-Datasette.__init__ = _tracking_init
-
-
-def pytest_addoption(parser):
-    parser.addini(
-        "datasette_autoclose",
-        help=(
-            "Automatically close Datasette instances created inside test "
-            "bodies and function-scoped fixtures (default: true)."
-        ),
-        default="true",
-    )
-
-
-def _enabled(config) -> bool:
-    value = config.getini("datasette_autoclose")
-    if isinstance(value, bool):
-        return value
-    return str(value).strip().lower() not in ("false", "0", "no", "off")
-
-
-@pytest.hookimpl(hookwrapper=True)
-def pytest_runtest_protocol(item, nextitem):
-    """Track Datasette instances across setup, call and teardown; close at end."""
-    if not _enabled(item.config):
-        yield
-        return
-    refs: list[weakref.ref] = []
-    token = _active_instances.set(refs)
-    try:
-        yield
-    finally:
-        _active_instances.reset(token)
-        for ref in reversed(refs):
-            ds = ref()
-            if ds is None:
-                continue
-            try:
-                ds.close()
-            except Exception as e:
-                item.warn(
-                    pytest.PytestUnraisableExceptionWarning(
-                        f"Error closing Datasette instance: {e!r}"
-                    )
-                )
-
-
-@pytest.hookimpl(hookwrapper=True)
-def pytest_fixture_setup(fixturedef, request):
-    """Exempt instances created by non-function-scoped fixtures.
-
-    Session-, module-, class- and package-scoped fixtures produce Datasette
-    instances that must survive beyond the current test — other tests in
-    the session will still use them. When such a fixture creates one or
-    more Datasette instances during its setup, we snapshot the tracking
-    list before the fixture runs and subtract off any instances that were
-    added during its setup, so they don't get closed at test teardown.
-    """
-    refs = _active_instances.get()
-    if refs is None:
-        yield
-        return
-    before_ids = {id(ref) for ref in refs}
-    yield
-    if fixturedef.scope != "function":
-        new_refs = [ref for ref in refs if id(ref) not in before_ids]
-        for new_ref in new_refs:
-            try:
-                refs.remove(new_ref)
-            except ValueError:
-                pass

datasette/cli.py

@@ -21,7 +21,6 @@ from .app import (
     SQLITE_LIMIT_ATTACHED,
     pm,
 )
-from .inspect import inspect_tables
 from .utils import (
     LoadExtension,
     StartupError,
@@ -110,11 +109,15 @@ def sqlite_extensions(fn):
             return fn(*args, **kwargs)
         except AttributeError as e:
             if "enable_load_extension" in str(e):
-                raise click.ClickException(textwrap.dedent("""
+                raise click.ClickException(
+                    textwrap.dedent(
+                        """
                     Your Python installation does not have the ability to load SQLite extensions.
 
                     More information: https://datasette.io/help/extensions
-                    """).strip())
+                    """
+                    ).strip()
+                )
             raise
 
     return wrapped
@@ -143,6 +146,7 @@ def inspect(files, inspect_file, sqlite_extensions):
     This can then be passed to "datasette --inspect-file" to speed up count
     operations against immutable database files.
     """
+    app = Datasette([], immutables=files, sqlite_extensions=sqlite_extensions)
     inspect_data = run_sync(lambda: inspect_(files, sqlite_extensions))
     if inspect_file == "-":
         sys.stdout.write(json.dumps(inspect_data, indent=2))
@@ -155,14 +159,14 @@ async def inspect_(files, sqlite_extensions):
     app = Datasette([], immutables=files, sqlite_extensions=sqlite_extensions)
     data = {}
     for name, database in app.databases.items():
-        tables = await database.execute_fn(lambda conn: inspect_tables(conn, {}))
+        counts = await database.table_counts(limit=3600 * 1000)
         data[name] = {
             "hash": database.hash,
             "size": database.size,
             "file": database.path,
             "tables": {
-                table_name: {"count": table["count"]}
-                for table_name, table in tables.items()
+                table_name: {"count": table_count}
+                for table_name, table_count in counts.items()
             },
         }
     return data
@@ -435,20 +439,10 @@ def uninstall(packages, yes):
     help="Output URL that sets a cookie authenticating the root user",
     is_flag=True,
 )
-@click.option(
-    "--default-deny",
-    help="Deny all permissions by default",
-    is_flag=True,
-)
 @click.option(
     "--get",
     help="Run an HTTP GET request against this path, print results and exit",
 )
-@click.option(
-    "--headers",
-    is_flag=True,
-    help="Include HTTP headers in --get output",
-)
 @click.option(
     "--token",
     help="API token to send with --get requests",
@@ -516,9 +510,7 @@ def serve(
     settings,
     secret,
     root,
-    default_deny,
     get,
-    headers,
     token,
     actor,
     version_note,
@@ -548,7 +540,7 @@ def serve(
     if reload:
         import hupper
 
-        reloader = hupper.start_reloader("datasette.cli.cli")
+        reloader = hupper.start_reloader("datasette.cli.serve")
         if immutable:
             reloader.watch_files(immutable)
         if config:
@@ -597,28 +589,18 @@ def serve(
         crossdb=crossdb,
         nolock=nolock,
         internal=internal,
-        default_deny=default_deny,
     )
 
-    # Separate directories from files
-    directories = [f for f in files if os.path.isdir(f)]
-    file_paths = [f for f in files if not os.path.isdir(f)]
-
-    # Handle config_dir - only one directory allowed
-    if len(directories) > 1:
-        raise click.ClickException(
-            "Cannot pass multiple directories. Pass a single directory as config_dir."
-        )
-    elif len(directories) == 1:
-        kwargs["config_dir"] = pathlib.Path(directories[0])
+    # if files is a single directory, use that as config_dir=
+    if 1 == len(files) and os.path.isdir(files[0]):
+        kwargs["config_dir"] = pathlib.Path(files[0])
+        files = []
 
     # Verify list of files, create if needed (and --create)
-    for file in file_paths:
+    for file in files:
         if not pathlib.Path(file).exists():
             if create:
-                conn = sqlite3.connect(file)
-                conn.execute("vacuum")
-                conn.close()
+                sqlite3.connect(file).execute("vacuum")
             else:
                 raise click.ClickException(
                     "Invalid value for '[FILES]...': Path '{}' does not exist.".format(
@@ -626,32 +608,8 @@ def serve(
                     )
                 )
 
-    # Check for duplicate files by resolving all paths to their absolute forms
-    # Collect all database files that will be loaded (explicit files + config_dir files)
-    all_db_files = []
-
-    # Add explicit files
-    for file in file_paths:
-        all_db_files.append((file, pathlib.Path(file).resolve()))
-
-    # Add config_dir databases if config_dir is set
-    if "config_dir" in kwargs:
-        config_dir = kwargs["config_dir"]
-        for ext in ("db", "sqlite", "sqlite3"):
-            for db_file in config_dir.glob(f"*.{ext}"):
-                all_db_files.append((str(db_file), db_file.resolve()))
-
-    # Check for duplicates
-    seen = {}
-    for original_path, resolved_path in all_db_files:
-        if resolved_path in seen:
-            raise click.ClickException(
-                f"Duplicate database file: '{original_path}' and '{seen[resolved_path]}' "
-                f"both refer to {resolved_path}"
-            )
-        seen[resolved_path] = original_path
-
-    files = file_paths
+    # De-duplicate files so 'datasette db.db db.db' only attaches one /db
+    files = list(dict.fromkeys(files))
 
     try:
         ds = Datasette(files, **kwargs)
@@ -664,43 +622,25 @@ def serve(
         # Private utility mechanism for writing unit tests
         return ds
 
-    # Run async soundness checks before startup hooks, since invoke_startup
-    # now populates internal tables which requires querying each database
-    run_sync(lambda: check_databases(ds))
-
     # Run the "startup" plugin hooks
-    try:
-        run_sync(ds.invoke_startup)
-    except StartupError as e:
-        raise click.ClickException(e.args[0])
+    run_sync(ds.invoke_startup)
 
-    if headers and not get:
-        raise click.ClickException("--headers can only be used with --get")
+    # Run async soundness checks - but only if we're not under pytest
+    run_sync(lambda: check_databases(ds))
 
     if token and not get:
         raise click.ClickException("--token can only be used with --get")
 
     if get:
         client = TestClient(ds)
-        request_headers = {}
+        headers = {}
         if token:
-            request_headers["Authorization"] = "Bearer {}".format(token)
+            headers["Authorization"] = "Bearer {}".format(token)
         cookies = {}
         if actor:
             cookies["ds_actor"] = client.actor_cookie(json.loads(actor))
-        response = client.get(get, headers=request_headers, cookies=cookies)
-
-        if headers:
-            # Output HTTP status code, headers, two newlines, then the response body
-            click.echo(f"HTTP/1.1 {response.status}")
-            for key, value in response.headers.items():
-                click.echo(f"{key}: {value}")
-            if response.text:
-                click.echo()
-                click.echo(response.text)
-        else:
-            click.echo(response.text)
-
+        response = client.get(get, headers=headers, cookies=cookies)
+        click.echo(response.text)
         exit_code = 0 if response.status == 200 else 1
         sys.exit(exit_code)
         return
@@ -708,7 +648,6 @@ def serve(
     # Start the server
     url = None
     if root:
-        ds.root_enabled = True
         url = "http://{}:{}{}?token={}".format(
             host, port, ds.urls.path("-/auth-token"), ds._root_token
         )
@@ -818,10 +757,7 @@ def create_token(
     ds = Datasette(secret=secret, plugins_dir=plugins_dir)
 
     # Run ds.invoke_startup() in an event loop
-    try:
-        run_sync(ds.invoke_startup)
-    except StartupError as e:
-        raise click.ClickException(e.args[0])
+    run_sync(ds.invoke_startup)
 
     # Warn about any unknown actions
     actions = []
@@ -829,30 +765,28 @@ def create_token(
     actions.extend([p[1] for p in databases])
     actions.extend([p[2] for p in resources])
     for action in actions:
-        if not ds.actions.get(action):
+        if not ds.permissions.get(action):
             click.secho(
                 f"  Unknown permission: {action} ",
                 fg="red",
                 err=True,
             )
 
-    from datasette.tokens import TokenRestrictions
-
-    restrictions = TokenRestrictions()
-    for action in alls:
-        restrictions.allow_all(action)
+    restrict_database = {}
     for database, action in databases:
-        restrictions.allow_database(database, action)
+        restrict_database.setdefault(database, []).append(action)
+    restrict_resource = {}
     for database, resource, action in resources:
-        restrictions.allow_resource(database, resource, action)
-
-    token = run_sync(
-        lambda: ds.create_token(
-            id,
-            expires_after=expires_after,
-            restrictions=restrictions,
-            handler="signed",
+        restrict_resource.setdefault(database, {}).setdefault(resource, []).append(
+            action
         )
+
+    token = ds.create_token(
+        id,
+        expires_after=expires_after,
+        restrict_all=alls,
+        restrict_database=restrict_database,
+        restrict_resource=restrict_resource,
     )
     click.echo(token)
     if debug:

datasette/column_types.py

@@ -1,83 +0,0 @@
-from enum import Enum
-
-
-class SQLiteType(Enum):
-    TEXT = "TEXT"
-    INTEGER = "INTEGER"
-    REAL = "REAL"
-    BLOB = "BLOB"
-    NULL = "NULL"
-
-    @classmethod
-    def from_declared_type(cls, declared_type: str | None) -> "SQLiteType | None":
-        if declared_type is None:
-            return cls.NULL
-
-        normalized = declared_type.strip().upper()
-        if not normalized:
-            return cls.NULL
-
-        if normalized == cls.NULL.value:
-            return cls.NULL
-        if "INT" in normalized:
-            return cls.INTEGER
-        if any(token in normalized for token in ("CHAR", "CLOB", "TEXT")):
-            return cls.TEXT
-        if "BLOB" in normalized:
-            return cls.BLOB
-        if any(
-            token in normalized
-            for token in ("REAL", "FLOA", "DOUB")  # codespell:ignore doub
-        ):
-            return cls.REAL
-
-        return None
-
-
-class ColumnType:
-    """
-    Base class for column types.
-
-    Subclasses must define ``name`` and ``description`` as class attributes:
-
-    - ``name``: Unique identifier string. Lowercase, no spaces.
-      Examples: "markdown", "file", "email", "url", "point", "image".
-    - ``description``: Human-readable label for admin UI dropdowns.
-      Examples: "Markdown text", "File reference", "Email address".
-    - ``sqlite_types``: Optional tuple of SQLiteType values restricting
-      which SQLite column types this ColumnType can be assigned to.
-
-    Instantiate with an optional ``config`` dict to bind per-column
-    configuration::
-
-        ct = MyColumnType(config={"key": "value"})
-        ct.config  # {"key": "value"}
-    """
-
-    name: str
-    description: str
-    sqlite_types: tuple[SQLiteType, ...] | None = None
-
-    def __init__(self, config=None):
-        self.config = config
-
-    async def render_cell(self, value, column, table, database, datasette, request):
-        """
-        Return an HTML string to render this cell value, or None to
-        fall through to the default render_cell plugin hook chain.
-        """
-        return None
-
-    async def validate(self, value, datasette):
-        """
-        Validate a value before it is written. Return None if valid,
-        or a string error message if invalid.
-        """
-        return None
-
-    async def transform_value(self, value, datasette):
-        """
-        Transform a value before it appears in JSON API output.
-        Return the transformed value. Default: return unchanged.
-        """
-        return value

datasette/csrf.py

@@ -1,178 +0,0 @@
-"""
-Header-based CSRF (Cross-Origin) protection.
-
-Datasette uses the Sec-Fetch-Site + Origin header approach described in
-Filippo Valsorda's article (https://words.filippo.io/csrf/) and implemented
-in Go 1.25's http.CrossOriginProtection. This replaces the previous
-token-based asgi-csrf mechanism.
-"""
-
-from __future__ import annotations
-
-import secrets
-import urllib.parse
-
-from .utils.asgi import asgi_send
-
-SAFE_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
-
-DEFAULT_PORTS = {"http": 80, "https": 443, "ws": 80, "wss": 443}
-
-
-def _normalize_headers(raw_headers):
-    """Lowercase header names; for duplicates, last value wins."""
-    result = {}
-    for name, value in raw_headers:
-        if isinstance(name, str):
-            name = name.encode("latin-1")
-        if isinstance(value, str):
-            value = value.encode("latin-1")
-        result[name.lower()] = value
-    return result
-
-
-def _origin_tuple(value):
-    """
-    Parse an origin-like string into ``(scheme, host, port)`` with default
-    ports filled in. Raises ``ValueError`` for malformed input.
-    """
-    parsed = urllib.parse.urlsplit(value)
-    scheme = (parsed.scheme or "").lower()
-    host = (parsed.hostname or "").lower()
-    if not scheme or not host:
-        raise ValueError("missing scheme or host in {!r}".format(value))
-    port = parsed.port  # may raise ValueError on bad ports
-    if port is None:
-        port = DEFAULT_PORTS.get(scheme)
-    if port is None:
-        raise ValueError("unknown default port for scheme {!r}".format(scheme))
-    return scheme, host, port
-
-
-def _install_legacy_csrftoken(scope):
-    """
-    Populate ``scope["csrftoken"]`` with a callable returning a per-request
-    random token. Provided for plugin compatibility only - core no longer
-    uses this value for CSRF enforcement.
-    """
-
-    def csrftoken():
-        if "_datasette_legacy_csrftoken" not in scope:
-            scope["_datasette_legacy_csrftoken"] = secrets.token_urlsafe(32)
-        return scope["_datasette_legacy_csrftoken"]
-
-    scope["csrftoken"] = csrftoken
-
-
-class CrossOriginProtectionMiddleware:
-    """
-    Modern CSRF protection using the Sec-Fetch-Site and Origin headers.
-
-    Based on Filippo Valsorda's algorithm, as implemented in Go 1.25's
-    http.CrossOriginProtection. See https://words.filippo.io/csrf/
-
-    Unsafe-method requests are allowed through only if they look same-origin.
-    Non-browser clients (curl, etc.) send neither Sec-Fetch-Site nor Origin
-    and are passed through unchanged - CSRF is a browser-only attack.
-    """
-
-    SAFE_METHODS = SAFE_METHODS
-
-    def __init__(self, app, datasette):
-        self.app = app
-        self.datasette = datasette
-
-    async def __call__(self, scope, receive, send):
-        if scope["type"] != "http":
-            await self.app(scope, receive, send)
-            return
-
-        _install_legacy_csrftoken(scope)
-
-        if scope.get("method", "GET") in self.SAFE_METHODS:
-            await self.app(scope, receive, send)
-            return
-
-        headers = _normalize_headers(scope.get("headers") or [])
-
-        authorization = headers.get(b"authorization", b"").decode("latin-1")
-        cookie_header = headers.get(b"cookie")
-        # Bearer-token requests are not ambient browser credentials, so they
-        # are not CSRF-vulnerable. Narrowly exempt them from the header check
-        # before evaluating Sec-Fetch-Site / Origin. Only "Bearer" is exempt;
-        # schemes like Basic or Digest can be browser-managed and ambient.
-        # If the request also carries a Cookie header, ambient cookie auth
-        # could be in play, so do NOT treat it as exempt.
-        if authorization and not cookie_header:
-            parts = authorization.split(None, 1)
-            if parts and parts[0].lower() == "bearer":
-                await self.app(scope, receive, send)
-                return
-
-        origin_bytes = headers.get(b"origin")
-        sec_fetch_site_bytes = headers.get(b"sec-fetch-site")
-        host_bytes = headers.get(b"host", b"")
-        origin = origin_bytes.decode("latin-1") if origin_bytes else None
-        sec_fetch_site = (
-            sec_fetch_site_bytes.decode("latin-1") if sec_fetch_site_bytes else None
-        )
-        host = host_bytes.decode("latin-1")
-
-        # Primary defense: Sec-Fetch-Site (set by browsers, unforgeable from JS)
-        if sec_fetch_site is not None:
-            if sec_fetch_site in ("same-origin", "none"):
-                await self.app(scope, receive, send)
-                return
-            await self._forbid(
-                send,
-                "Sec-Fetch-Site was {!r}, expected 'same-origin' or 'none'".format(
-                    sec_fetch_site
-                ),
-            )
-            return
-
-        # No Sec-Fetch-Site and no Origin -> non-browser client (curl, API, etc.)
-        if origin is None:
-            await self.app(scope, receive, send)
-            return
-
-        # Fallback for older browsers: Origin must match the request's own
-        # scheme + host + port. Compare full origin tuples, not host alone.
-        request_scheme = self._request_scheme(scope)
-        try:
-            origin_tuple = _origin_tuple(origin)
-            expected_tuple = _origin_tuple("{}://{}".format(request_scheme, host))
-        except ValueError:
-            await self._forbid(
-                send,
-                "Malformed Origin {!r} or Host {!r}".format(origin, host),
-            )
-            return
-
-        if origin_tuple == expected_tuple:
-            await self.app(scope, receive, send)
-            return
-
-        await self._forbid(
-            send,
-            "Origin {!r} does not match Host {!r}".format(origin, host),
-        )
-
-    def _request_scheme(self, scope):
-        if self.datasette is not None:
-            try:
-                if self.datasette.setting("force_https_urls"):
-                    return "https"
-            except Exception:
-                pass
-        return scope.get("scheme") or "http"
-
-    async def _forbid(self, send, reason):
-        await asgi_send(
-            send,
-            content=await self.datasette.render_template(
-                "csrf_error.html", {"reason": reason}
-            ),
-            status=403,
-            content_type="text/html; charset=utf-8",
-        )

datasette/database.py

@@ -1,19 +1,15 @@
 import asyncio
-import atexit
 from collections import namedtuple
-import inspect
-import os
 from pathlib import Path
+import janus
 import queue
 import sqlite_utils
 import sys
-import tempfile
 import threading
 import uuid
 
 from .tracer import trace
 from .utils import (
-    call_with_supported_arguments,
     detect_fts,
     detect_primary_keys,
     detect_spatialite,
@@ -25,8 +21,7 @@ from .utils import (
     table_columns,
     table_column_details,
 )
-from .utils.sql_analysis import SQLAnalysis, analyze_sql_tables
-from .utils.sqlite import sqlite_hidden_table_names
+from .utils.sqlite import sqlite_version
 from .inspect import inspect_hash
 
 connections = threading.local()
@@ -34,13 +29,6 @@ connections = threading.local()
 AttachedDatabase = namedtuple("AttachedDatabase", ("seq", "name", "file"))
 
 
-class DatasetteClosedError(RuntimeError):
-    """Raised when using a Datasette or Database instance after close()."""
-
-
-_SHUTDOWN = object()
-
-
 class Database:
     # For table counts stop at this many rows:
     count_limit = 10000
@@ -54,7 +42,6 @@ class Database:
         is_memory=False,
         memory_name=None,
         mode=None,
-        is_temp_disk=False,
     ):
         self.name = None
         self._thread_local_id = f"x{self._thread_local_id_counter}"
@@ -65,44 +52,19 @@ class Database:
         self.is_mutable = is_mutable
         self.is_memory = is_memory
         self.memory_name = memory_name
-        self.is_temp_disk = is_temp_disk
         if memory_name is not None:
             self.is_memory = True
-        if is_temp_disk:
-            fd, temp_path = tempfile.mkstemp(suffix=".db", prefix="datasette_temp_")
-            os.close(fd)
-            self.path = temp_path
-            self.is_mutable = True
-            self.mode = "rwc"
-            self._wal_enabled = False
-            atexit.register(self._cleanup_temp_file)
-        else:
-            self._wal_enabled = False
         self.cached_hash = None
         self.cached_size = None
         self._cached_table_counts = None
         self._write_thread = None
         self._write_queue = None
-        self._closed = False
-        self._pending_execute_futures = set()
-        self._pending_execute_futures_lock = threading.Lock()
         # These are used when in non-threaded mode:
         self._read_connection = None
         self._write_connection = None
         # This is used to track all file connections so they can be closed
         self._all_file_connections = []
-        if not is_temp_disk:
-            self.mode = mode
-
-    def _check_not_closed(self):
-        if self._closed:
-            raise DatasetteClosedError(
-                "Database {!r} has been closed".format(self.name)
-            )
-
-    def _remove_pending_execute_future(self, future):
-        with self._pending_execute_futures_lock:
-            self._pending_execute_futures.discard(future)
+        self.mode = mode
 
     @property
     def cached_table_counts(self):
@@ -123,8 +85,6 @@ class Database:
         return md5_not_usedforsecurity(self.name)[:6]
 
     def suggest_name(self):
-        if self.is_temp_disk:
-            return "_temp_disk"
         if self.path:
             return Path(self.path).stem
         elif self.memory_name:
@@ -163,104 +123,30 @@ class Database:
             f"file:{self.path}{qs}", uri=True, check_same_thread=False, **extra_kwargs
         )
         self._all_file_connections.append(conn)
-        if self.is_temp_disk and not self._wal_enabled:
-            conn.execute("PRAGMA journal_mode=WAL")
-            self._wal_enabled = True
         return conn
 
     def close(self):
-        """Release all resources held by this database.
-
-        Idempotent. After close() further calls to execute()/execute_fn()/
-        execute_write()/execute_write_fn() raise DatasetteClosedError.
-        """
-        if self._closed:
-            return
-        with self._pending_execute_futures_lock:
-            if self._closed:
-                return
-            self._closed = True
-            pending_execute_futures = tuple(self._pending_execute_futures)
-        # Shut down the write thread, if any, via a sentinel. The thread
-        # drains any writes already queued before the sentinel and then
-        # closes its own write connection and returns.
-        write_thread = self._write_thread
-        if write_thread is not None and self._write_queue is not None:
-            self._write_queue.put(_SHUTDOWN)
-            write_thread.join(timeout=10)
-            if write_thread.is_alive():
-                sys.stderr.write(
-                    "Datasette: write thread for {!r} did not exit within 10s\n".format(
-                        self.name
-                    )
-                )
-                sys.stderr.flush()
-        for future in pending_execute_futures:
-            try:
-                future.result()
-            except Exception:
-                pass
-        # Close anything still tracked in _all_file_connections
+        # Close all connections - useful to avoid running out of file handles in tests
         for connection in self._all_file_connections:
-            try:
-                connection.close()
-            except Exception:
-                pass
-        self._all_file_connections = []
-        # Drop per-thread cached read connections we can reach
-        try:
-            delattr(connections, self._thread_local_id)
-        except AttributeError:
-            pass
-        # Close non-threaded-mode cached connections if still open
-        if self._read_connection is not None:
-            try:
-                self._read_connection.close()
-            except Exception:
-                pass
-            self._read_connection = None
-        if self._write_connection is not None:
-            try:
-                self._write_connection.close()
-            except Exception:
-                pass
-            self._write_connection = None
-        if self.is_temp_disk:
-            self._cleanup_temp_file()
-
-    def _cleanup_temp_file(self):
-        if self.is_temp_disk and self.path:
-            for suffix in ("", "-wal", "-shm"):
-                try:
-                    os.unlink(self.path + suffix)
-                except OSError:
-                    pass
-
-    async def execute_write(self, sql, params=None, block=True, request=None):
-        self._check_not_closed()
+            connection.close()
 
+    async def execute_write(self, sql, params=None, block=True):
         def _inner(conn):
             return conn.execute(sql, params or [])
 
         with trace("sql", database=self.name, sql=sql.strip(), params=params):
-            results = await self.execute_write_fn(_inner, block=block, request=request)
+            results = await self.execute_write_fn(_inner, block=block)
         return results
 
-    async def execute_write_script(self, sql, block=True, request=None):
-        self._check_not_closed()
-
+    async def execute_write_script(self, sql, block=True):
         def _inner(conn):
             return conn.executescript(sql)
 
         with trace("sql", database=self.name, sql=sql.strip(), executescript=True):
-            results = await self.execute_write_fn(
-                _inner, block=block, transaction=False, request=request
-            )
+            results = await self.execute_write_fn(_inner, block=block)
         return results
 
-    async def execute_write_many(self, sql, params_seq, block=True, request=None):
-        self._check_not_closed()
-
+    async def execute_write_many(self, sql, params_seq, block=True):
         def _inner(conn):
             count = 0
 
@@ -275,14 +161,11 @@ class Database:
         with trace(
             "sql", database=self.name, sql=sql.strip(), executemany=True
         ) as kwargs:
-            results, count = await self.execute_write_fn(
-                _inner, block=block, request=request
-            )
+            results, count = await self.execute_write_fn(_inner, block=block)
             kwargs["count"] = count
         return results
 
     async def execute_isolated_fn(self, fn):
-        self._check_not_closed()
         # Open a new connection just for the duration of this function
         # blocking the write queue to avoid any writes occurring during it
         if self.ds.executor is None:
@@ -302,21 +185,7 @@ class Database:
             # Threaded mode - send to write thread
             return await self._send_to_write_thread(fn, isolated_connection=True)
 
-    async def analyze_sql(self, sql, params=None) -> SQLAnalysis:
-        self._check_not_closed()
-
-        return await self.execute_isolated_fn(
-            lambda conn: analyze_sql_tables(conn, sql, params, database_name=self.name)
-        )
-
-    async def execute_write_fn(self, fn, block=True, transaction=True, request=None):
-        self._check_not_closed()
-        pending_events = []
-
-        def track_event(event):
-            pending_events.append(event)
-
-        fn = self._wrap_fn_with_hooks(fn, request, transaction, track_event)
+    async def execute_write_fn(self, fn, block=True, transaction=True):
         if self.ds.executor is None:
             # non-threaded mode
             if self._write_connection is None:
@@ -324,67 +193,13 @@ class Database:
                 self.ds._prepare_connection(self._write_connection, self.name)
             if transaction:
                 with self._write_connection:
-                    result = fn(self._write_connection)
+                    return fn(self._write_connection)
             else:
-                result = fn(self._write_connection)
+                return fn(self._write_connection)
         else:
-            result = await self._send_to_write_thread(
+            return await self._send_to_write_thread(
                 fn, block=block, transaction=transaction
             )
-        if block:
-            for event in pending_events:
-                await self.ds.track_event(event)
-        else:
-            # For non-blocking writes, spawn a background task to
-            # dispatch events after the write thread completes
-            task_id, reply_future = result
-
-            async def _dispatch_events_after_write():
-                try:
-                    await reply_future
-                except Exception:
-                    # if the write failed, don't emit success events
-                    return
-                for event in pending_events:
-                    await self.ds.track_event(event)
-
-            asyncio.ensure_future(_dispatch_events_after_write())
-            result = task_id
-        return result
-
-    def _wrap_fn_with_hooks(self, fn, request, transaction, track_event):
-        from .plugins import pm
-
-        # Wrap fn so it receives track_event if its signature supports it.
-        # Historically fn was called positionally, so any single-parameter
-        # name (conn, connection, db, ...) worked. Preserve that by only
-        # switching to keyword dependency injection when the callback
-        # explicitly opts in by declaring a `track_event` parameter.
-        original_fn = fn
-
-        if "track_event" in inspect.signature(original_fn).parameters:
-
-            def fn_with_track_event(conn):
-                return call_with_supported_arguments(
-                    original_fn, conn=conn, track_event=track_event
-                )
-
-            fn = fn_with_track_event
-
-        wrappers = pm.hook.write_wrapper(
-            datasette=self.ds,
-            database=self.name,
-            request=request,
-            transaction=transaction,
-        )
-        wrappers = [w for w in wrappers if w is not None]
-        if not wrappers:
-            return fn
-        # Build the wrapped fn by nesting context manager generators.
-        # The first wrapper returned by pluggy is outermost.
-        for wrapper_factory in reversed(wrappers):
-            fn = _apply_write_wrapper(fn, wrapper_factory, track_event)
-        return fn
 
     async def _send_to_write_thread(
         self, fn, block=True, isolated_connection=False, transaction=True
@@ -400,15 +215,18 @@ class Database:
             )
             self._write_thread.start()
         task_id = uuid.uuid5(uuid.NAMESPACE_DNS, "datasette.io")
-        loop = asyncio.get_running_loop()
-        reply_future = loop.create_future()
+        reply_queue = janus.Queue()
         self._write_queue.put(
-            WriteTask(fn, task_id, loop, reply_future, isolated_connection, transaction)
+            WriteTask(fn, task_id, reply_queue, isolated_connection, transaction)
         )
         if block:
-            return await reply_future
+            result = await reply_queue.async_q.get()
+            if isinstance(result, Exception):
+                raise result
+            else:
+                return result
         else:
-            return task_id, reply_future
+            return task_id
 
     def _execute_writes(self):
         # Infinite looping thread that protects the single write connection
@@ -422,47 +240,38 @@ class Database:
             conn_exception = e
         while True:
             task = self._write_queue.get()
-            if task is _SHUTDOWN:
-                if conn is not None:
-                    try:
-                        conn.close()
-                    except Exception:
-                        pass
-                return
-            exception = None
-            result = None
             if conn_exception is not None:
-                exception = conn_exception
-            elif task.isolated_connection:
-                isolated_connection = self.connect(write=True)
-                try:
-                    result = task.fn(isolated_connection)
-                except Exception as e:
-                    sys.stderr.write("{}\n".format(e))
-                    sys.stderr.flush()
-                    exception = e
-                finally:
-                    isolated_connection.close()
-                    try:
-                        self._all_file_connections.remove(isolated_connection)
-                    except ValueError:
-                        # Was probably a memory connection
-                        pass
+                result = conn_exception
             else:
-                try:
-                    if task.transaction:
-                        with conn:
+                if task.isolated_connection:
+                    isolated_connection = self.connect(write=True)
+                    try:
+                        result = task.fn(isolated_connection)
+                    except Exception as e:
+                        sys.stderr.write("{}\n".format(e))
+                        sys.stderr.flush()
+                        result = e
+                    finally:
+                        isolated_connection.close()
+                        try:
+                            self._all_file_connections.remove(isolated_connection)
+                        except ValueError:
+                            # Was probably a memory connection
+                            pass
+                else:
+                    try:
+                        if task.transaction:
+                            with conn:
+                                result = task.fn(conn)
+                        else:
                             result = task.fn(conn)
-                    else:
-                        result = task.fn(conn)
-                except Exception as e:
-                    sys.stderr.write("{}\n".format(e))
-                    sys.stderr.flush()
-                    exception = e
-            _deliver_write_result(task, result, exception)
+                    except Exception as e:
+                        sys.stderr.write("{}\n".format(e))
+                        sys.stderr.flush()
+                        result = e
+            task.reply_queue.sync_q.put(result)
 
     async def execute_fn(self, fn):
-        self._check_not_closed()
         if self.ds.executor is None:
             # non-threaded mode
             if self._read_connection is None:
@@ -479,12 +288,9 @@ class Database:
                 setattr(connections, self._thread_local_id, conn)
             return fn(conn)
 
-        with self._pending_execute_futures_lock:
-            self._check_not_closed()
-            future = self.ds.executor.submit(in_thread)
-            self._pending_execute_futures.add(future)
-        future.add_done_callback(self._remove_pending_execute_future)
-        return await asyncio.wrap_future(future)
+        return await asyncio.get_event_loop().run_in_executor(
+            self.ds.executor, in_thread
+        )
 
     async def execute(
         self,
@@ -496,7 +302,6 @@ class Database:
         log_sql_errors=True,
     ):
         """Executes sql against db_name in a thread"""
-        self._check_not_closed()
         page_size = page_size or self.ds.page_size
 
         def sql_operation_in_thread(conn):
@@ -544,7 +349,7 @@ class Database:
     def hash(self):
         if self.cached_hash is not None:
             return self.cached_hash
-        elif self.is_mutable or self.is_memory or self.is_temp_disk:
+        elif self.is_mutable or self.is_memory:
             return None
         elif self.ds.inspect_data and self.ds.inspect_data.get(self.name):
             self.cached_hash = self.ds.inspect_data[self.name]["hash"]
@@ -603,12 +408,7 @@ class Database:
         # But SQLite prior to 3.16.0 doesn't support pragma functions
         results = await self.execute("PRAGMA database_list;")
         # {'seq': 0, 'name': 'main', 'file': ''}
-        return [
-            AttachedDatabase(*row)
-            for row in results.rows
-            # Filter out the SQLite internal "temp" database, refs #2557
-            if row["seq"] > 0 and row["name"] != "temp"
-        ]
+        return [AttachedDatabase(*row) for row in results.rows if row["seq"] > 0]
 
     async def table_exists(self, table):
         results = await self.execute(
@@ -624,7 +424,7 @@ class Database:
 
     async def table_names(self):
         results = await self.execute(
-            "select name from sqlite_master where type='table' order by name"
+            "select name from sqlite_master where type='table'"
         )
         return [r[0] for r in results.rows]
 
@@ -702,7 +502,98 @@ class Database:
                 t for t in db_config["tables"] if db_config["tables"][t].get("hidden")
             ]
 
-        hidden_tables += await self.execute_fn(sqlite_hidden_table_names)
+        if sqlite_version()[1] >= 37:
+            hidden_tables += [
+                x[0]
+                for x in await self.execute(
+                    """
+                      with shadow_tables as (
+                        select name
+                        from pragma_table_list
+                        where [type] = 'shadow'
+                        order by name
+                      ),
+                      core_tables as (
+                        select name
+                        from sqlite_master
+                        WHERE  name in ('sqlite_stat1', 'sqlite_stat2', 'sqlite_stat3', 'sqlite_stat4')
+                          OR substr(name, 1, 1) == '_'
+                      ),
+                      combined as (
+                        select name from shadow_tables
+                        union all
+                        select name from core_tables
+                      )
+                      select name from combined order by 1
+                    """
+                )
+            ]
+        else:
+            hidden_tables += [
+                x[0]
+                for x in await self.execute(
+                    """
+                      WITH base AS (
+                        SELECT name
+                        FROM sqlite_master
+                        WHERE  name IN ('sqlite_stat1', 'sqlite_stat2', 'sqlite_stat3', 'sqlite_stat4')
+                          OR substr(name, 1, 1) == '_'
+                      ),
+                      fts_suffixes AS (
+                        SELECT column1 AS suffix
+                        FROM (VALUES ('_data'), ('_idx'), ('_docsize'), ('_content'), ('_config'))
+                      ),
+                      fts5_names AS (
+                        SELECT name
+                        FROM sqlite_master
+                        WHERE sql LIKE '%VIRTUAL TABLE%USING FTS%'
+                      ),
+                      fts5_shadow_tables AS (
+                        SELECT
+                          printf('%s%s', fts5_names.name, fts_suffixes.suffix) AS name
+                        FROM fts5_names
+                        JOIN fts_suffixes
+                      ),
+                      fts3_suffixes AS (
+                        SELECT column1 AS suffix
+                        FROM (VALUES ('_content'), ('_segdir'), ('_segments'), ('_stat'), ('_docsize'))
+                      ),
+                      fts3_names AS (
+                        SELECT name
+                        FROM sqlite_master
+                        WHERE sql LIKE '%VIRTUAL TABLE%USING FTS3%'
+                          OR sql LIKE '%VIRTUAL TABLE%USING FTS4%'
+                      ),
+                      fts3_shadow_tables AS (
+                        SELECT
+                          printf('%s%s', fts3_names.name, fts3_suffixes.suffix) AS name
+                        FROM fts3_names
+                        JOIN fts3_suffixes
+                      ),
+                      final AS (
+                        SELECT name FROM base
+                        UNION ALL
+                        SELECT name FROM fts5_shadow_tables
+                        UNION ALL
+                        SELECT name FROM fts3_shadow_tables
+                      )
+                      SELECT name FROM final ORDER BY 1
+                    """
+                )
+            ]
+        # Also hide any FTS tables that have a content= argument
+        hidden_tables += [
+            x[0]
+            for x in await self.execute(
+                """
+                  SELECT name
+                  FROM sqlite_master
+                  WHERE sql LIKE '%VIRTUAL TABLE%'
+                    AND sql LIKE '%USING FTS%'
+                    AND sql LIKE '%content=%'
+                """
+            )
+        ]
 
         has_spatialite = await self.execute_fn(detect_spatialite)
         if has_spatialite:
@@ -721,11 +612,16 @@ class Database:
                 "KNN",
                 "KNN2",
             ] + [
-                r[0] for r in (await self.execute("""
+                r[0]
+                for r in (
+                    await self.execute(
+                        """
                         select name from sqlite_master
                         where name like "idx_%"
                         and type = "table"
-                    """)).rows
+                    """
+                    )
+                ).rows
             ]
 
         return hidden_tables
@@ -767,8 +663,6 @@ class Database:
             tags.append("mutable")
         if self.is_memory:
             tags.append("memory")
-        if self.is_temp_disk:
-            tags.append("temp_disk")
         if self.hash:
             tags.append(f"hash={self.hash}")
         if self.size is not None:
@@ -779,90 +673,17 @@ class Database:
         return f"<Database: {self.name}{tags_str}>"
 
 
-def _apply_write_wrapper(fn, wrapper_factory, track_event):
-    """Apply a single write_wrapper context manager around fn.
-
-    ``wrapper_factory`` is a callable that takes ``(conn)`` and optionally
-    ``track_event``, and returns a generator that yields exactly once.
-    Code before the yield runs before ``fn(conn)``, code after the yield
-    runs after.  The result of ``fn(conn)`` is sent into the generator
-    via ``.send()``, and any exception raised by ``fn(conn)`` is thrown
-    via ``.throw()``.
-    """
-
-    def wrapped(conn):
-        gen = call_with_supported_arguments(
-            wrapper_factory, conn=conn, track_event=track_event
-        )
-        # Advance to the yield point (run "before" code)
-        try:
-            next(gen)
-        except StopIteration:
-            # Generator didn't yield — just run fn unchanged
-            return fn(conn)
-
-        # Execute the actual write
-        try:
-            result = fn(conn)
-        except Exception:
-            # Throw exception into generator so it can handle it
-            try:
-                gen.throw(*sys.exc_info())
-            except StopIteration:
-                pass
-            # Re-raise the original exception
-            raise
-        else:
-            # Send the result back through the yield
-            try:
-                gen.send(result)
-            except StopIteration:
-                pass
-            return result
-
-    return wrapped
-
-
 class WriteTask:
-    __slots__ = (
-        "fn",
-        "task_id",
-        "loop",
-        "reply_future",
-        "isolated_connection",
-        "transaction",
-    )
+    __slots__ = ("fn", "task_id", "reply_queue", "isolated_connection", "transaction")
 
-    def __init__(
-        self, fn, task_id, loop, reply_future, isolated_connection, transaction
-    ):
+    def __init__(self, fn, task_id, reply_queue, isolated_connection, transaction):
         self.fn = fn
         self.task_id = task_id
-        self.loop = loop
-        self.reply_future = reply_future
+        self.reply_queue = reply_queue
         self.isolated_connection = isolated_connection
         self.transaction = transaction
 
 
-def _deliver_write_result(task, result, exception):
-    # Called from the write thread. Delivers the result back to the
-    # awaiting coroutine on its event loop via call_soon_threadsafe.
-    def _set():
-        if task.reply_future.done():
-            # Awaiter was cancelled; nothing to do.
-            return
-        if exception is not None:
-            task.reply_future.set_exception(exception)
-        else:
-            task.reply_future.set_result(result)
-
-    try:
-        task.loop.call_soon_threadsafe(_set)
-    except RuntimeError:
-        # Event loop has been closed; the awaiter is gone.
-        pass
-
-
 class QueryInterrupted(Exception):
     def __init__(self, e, sql, params):
         self.e = e

datasette/default_actions.py

@@ -1,133 +0,0 @@
-from datasette import hookimpl
-from datasette.permissions import Action
-from datasette.resources import (
-    DatabaseResource,
-    TableResource,
-    QueryResource,
-)
-
-
-@hookimpl
-def register_actions():
-    """Register the core Datasette actions."""
-    return (
-        # Global actions (no resource_class)
-        Action(
-            name="view-instance",
-            abbr="vi",
-            description="View Datasette instance",
-        ),
-        Action(
-            name="permissions-debug",
-            abbr="pd",
-            description="Access permission debug tool",
-        ),
-        Action(
-            name="debug-menu",
-            abbr="dm",
-            description="View debug menu items",
-        ),
-        # Database-level actions (parent-level)
-        Action(
-            name="view-database",
-            abbr="vd",
-            description="View database",
-            resource_class=DatabaseResource,
-        ),
-        Action(
-            name="view-database-download",
-            abbr="vdd",
-            description="Download database file",
-            resource_class=DatabaseResource,
-            also_requires="view-database",
-        ),
-        Action(
-            name="execute-sql",
-            abbr="es",
-            description="Execute read-only SQL queries",
-            resource_class=DatabaseResource,
-            also_requires="view-database",
-        ),
-        Action(
-            name="execute-write-sql",
-            abbr="ews",
-            description="Execute writable SQL queries",
-            resource_class=DatabaseResource,
-            also_requires="view-database",
-        ),
-        Action(
-            name="create-table",
-            abbr="ct",
-            description="Create tables",
-            resource_class=DatabaseResource,
-        ),
-        Action(
-            name="store-query",
-            abbr="sq",
-            description="Create stored queries",
-            resource_class=DatabaseResource,
-            also_requires="execute-sql",
-        ),
-        # Table-level actions (child-level)
-        Action(
-            name="view-table",
-            abbr="vt",
-            description="View table",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="insert-row",
-            abbr="ir",
-            description="Insert rows",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="delete-row",
-            abbr="dr",
-            description="Delete rows",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="update-row",
-            abbr="ur",
-            description="Update rows",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="alter-table",
-            abbr="at",
-            description="Alter tables",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="set-column-type",
-            abbr="sct",
-            description="Set column type",
-            resource_class=TableResource,
-        ),
-        Action(
-            name="drop-table",
-            abbr="dt",
-            description="Drop tables",
-            resource_class=TableResource,
-        ),
-        # Query-level actions (child-level)
-        Action(
-            name="view-query",
-            abbr="vq",
-            description="View named query results",
-            resource_class=QueryResource,
-        ),
-        Action(
-            name="update-query",
-            abbr="uq",
-            description="Update stored queries",
-            resource_class=QueryResource,
-        ),
-        Action(
-            name="delete-query",
-            abbr="dq",
-            description="Delete stored queries",
-            resource_class=QueryResource,
-        ),
-    )

datasette/default_column_types.py

@@ -1,81 +0,0 @@
-import json
-import re
-
-import markupsafe
-
-from datasette import hookimpl
-from datasette.column_types import ColumnType, SQLiteType
-
-
-class UrlColumnType(ColumnType):
-    name = "url"
-    description = "URL"
-    sqlite_types = (SQLiteType.TEXT,)
-
-    async def render_cell(self, value, column, table, database, datasette, request):
-        if not value or not isinstance(value, str):
-            return None
-        escaped = markupsafe.escape(value.strip())
-        return markupsafe.Markup(f'<a href="{escaped}">{escaped}</a>')
-
-    async def validate(self, value, datasette):
-        if value is None or value == "":
-            return None
-        if not isinstance(value, str):
-            return "URL must be a string"
-        if not re.match(r"^https?://\S+$", value.strip()):
-            return "Invalid URL"
-        return None
-
-
-class EmailColumnType(ColumnType):
-    name = "email"
-    description = "Email address"
-    sqlite_types = (SQLiteType.TEXT,)
-
-    async def render_cell(self, value, column, table, database, datasette, request):
-        if not value or not isinstance(value, str):
-            return None
-        escaped = markupsafe.escape(value.strip())
-        return markupsafe.Markup(f'<a href="mailto:{escaped}">{escaped}</a>')
-
-    async def validate(self, value, datasette):
-        if value is None or value == "":
-            return None
-        if not isinstance(value, str):
-            return "Email must be a string"
-        if not re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", value.strip()):
-            return "Invalid email address"
-        return None
-
-
-class JsonColumnType(ColumnType):
-    name = "json"
-    description = "JSON data"
-    sqlite_types = (SQLiteType.TEXT,)
-
-    async def render_cell(self, value, column, table, database, datasette, request):
-        if value is None:
-            return None
-        try:
-            parsed = json.loads(value) if isinstance(value, str) else value
-            formatted = json.dumps(parsed, indent=2)
-            escaped = markupsafe.escape(formatted)
-            return markupsafe.Markup(f"<pre>{escaped}</pre>")
-        except (json.JSONDecodeError, TypeError):
-            return None
-
-    async def validate(self, value, datasette):
-        if value is None or value == "":
-            return None
-        if isinstance(value, str):
-            try:
-                json.loads(value)
-            except json.JSONDecodeError:
-                return "Invalid JSON"
-        return None
-
-
-@hookimpl
-def register_column_types(datasette):
-    return [UrlColumnType, EmailColumnType, JsonColumnType]

datasette/default_database_actions.py

@@ -1,24 +0,0 @@
-from datasette import hookimpl
-from datasette.resources import DatabaseResource
-
-
-@hookimpl
-def database_actions(datasette, actor, database, request):
-    async def inner():
-        if not datasette.get_database(database).is_mutable:
-            return []
-        if not await datasette.allowed(
-            action="execute-write-sql",
-            resource=DatabaseResource(database),
-            actor=actor,
-        ):
-            return []
-        return [
-            {
-                "href": datasette.urls.database(database) + "/-/execute-write",
-                "label": "Execute write SQL",
-                "description": "Run writable SQL with table permission checks.",
-            }
-        ]
-
-    return inner

datasette/default_debug_menu.py

@@ -1,75 +0,0 @@
-from datasette import hookimpl
-from datasette.jump import JumpSQL
-
-DEBUG_MENU_ITEMS = (
-    (
-        "/-/databases",
-        "Databases",
-        "List of databases known to this Datasette instance.",
-    ),
-    (
-        "/-/plugins",
-        "Installed plugins",
-        "Review loaded plugins, their versions and their registered hooks.",
-    ),
-    (
-        "/-/versions",
-        "Version info",
-        "Check the Python, SQLite and dependency versions used by this server.",
-    ),
-    (
-        "/-/settings",
-        "Settings",
-        "Inspect the active Datasette settings and configuration values.",
-    ),
-    (
-        "/-/permissions",
-        "Debug permissions",
-        "Test permission checks for actors, actions and resources.",
-    ),
-    (
-        "/-/messages",
-        "Debug messages",
-        "Try out temporary flash messages shown to users.",
-    ),
-    (
-        "/-/allow-debug",
-        "Debug allow rules",
-        "Explore how allow blocks match actors against permission rules.",
-    ),
-    (
-        "/-/threads",
-        "Debug threads",
-        "Inspect worker threads and database tasks.",
-    ),
-    (
-        "/-/actor",
-        "Debug actor",
-        "View the actor object for the current signed-in user.",
-    ),
-    (
-        "/-/patterns",
-        "Pattern portfolio",
-        "Browse Datasette UI patterns.",
-    ),
-)
-
-
-@hookimpl
-def jump_items_sql(datasette, actor, request):
-    async def inner():
-        if not await datasette.allowed(action="debug-menu", actor=actor):
-            return []
-
-        return [
-            JumpSQL.menu_item(
-                label=label,
-                url=datasette.urls.path(path),
-                description=description,
-                search_text=f"debug {label} {description}",
-                item_type="debug",
-            )
-            for path, label, description in DEBUG_MENU_ITEMS
-        ]
-
-    return inner

datasette/default_jump_items.py

@@ -1,82 +0,0 @@
-from datasette import hookimpl
-from datasette.jump import JumpSQL
-
-
-@hookimpl
-def jump_items_sql(datasette, actor, request):
-    async def inner():
-        database_sql, database_params = await datasette.allowed_resources_sql(
-            action="view-database", actor=actor
-        )
-        table_sql, table_params = await datasette.allowed_resources_sql(
-            action="view-table", actor=actor
-        )
-        query_sql, query_params = await datasette.allowed_resources_sql(
-            action="view-query", actor=actor
-        )
-        return [
-            JumpSQL(
-                sql=f"""
-                WITH allowed_databases AS (
-                    {database_sql}
-                )
-                SELECT
-                    'database' AS type,
-                    parent AS label,
-                    NULL AS description,
-                    json_object(
-                        'method', 'database',
-                        'database', parent
-                    ) AS url,
-                    parent AS search_text,
-                    NULL AS display_name
-                FROM allowed_databases
-                """,
-                params=database_params,
-            ),
-            JumpSQL(
-                sql=f"""
-                WITH allowed_tables AS (
-                    {table_sql}
-                )
-                SELECT
-                    CASE WHEN catalog_views.view_name IS NULL THEN 'table' ELSE 'view' END AS type,
-                    allowed_tables.parent || ': ' || allowed_tables.child AS label,
-                    NULL AS description,
-                    json_object(
-                        'method', 'table',
-                        'database', allowed_tables.parent,
-                        'table', allowed_tables.child
-                    ) AS url,
-                    allowed_tables.parent || ' ' || allowed_tables.child AS search_text,
-                    NULL AS display_name
-                FROM allowed_tables
-                LEFT JOIN catalog_views
-                    ON catalog_views.database_name = allowed_tables.parent
-                   AND catalog_views.view_name = allowed_tables.child
-                """,
-                params=table_params,
-            ),
-            JumpSQL(
-                sql=f"""
-                WITH allowed_queries AS (
-                    {query_sql}
-                )
-                SELECT
-                    'query' AS type,
-                    allowed_queries.parent || ': ' || allowed_queries.child AS label,
-                    NULL AS description,
-                    json_object(
-                        'method', 'query',
-                        'database', allowed_queries.parent,
-                        'query', allowed_queries.child
-                    ) AS url,
-                    allowed_queries.parent || ' ' || allowed_queries.child AS search_text,
-                    NULL AS display_name
-                FROM allowed_queries
-                """,
-                params=query_params,
-            ),
-        ]
-
-    return inner

datasette/default_menu_links.py

@@ -0,0 +1,41 @@
+from datasette import hookimpl
+
+
+@hookimpl
+def menu_links(datasette, actor):
+    async def inner():
+        if not await datasette.permission_allowed(actor, "debug-menu"):
+            return []
+
+        return [
+            {"href": datasette.urls.path("/-/databases"), "label": "Databases"},
+            {
+                "href": datasette.urls.path("/-/plugins"),
+                "label": "Installed plugins",
+            },
+            {
+                "href": datasette.urls.path("/-/versions"),
+                "label": "Version info",
+            },
+            {
+                "href": datasette.urls.path("/-/settings"),
+                "label": "Settings",
+            },
+            {
+                "href": datasette.urls.path("/-/permissions"),
+                "label": "Debug permissions",
+            },
+            {
+                "href": datasette.urls.path("/-/messages"),
+                "label": "Debug messages",
+            },
+            {
+                "href": datasette.urls.path("/-/allow-debug"),
+                "label": "Debug allow rules",
+            },
+            {"href": datasette.urls.path("/-/threads"), "label": "Debug threads"},
+            {"href": datasette.urls.path("/-/actor"), "label": "Debug actor"},
+            {"href": datasette.urls.path("/-/patterns"), "label": "Pattern portfolio"},
+        ]
+
+    return inner

datasette/default_permissions.py

@@ -0,0 +1,577 @@
+from datasette import hookimpl, Permission
+from datasette.utils.permissions import PluginSQL
+from datasette.utils import actor_matches_allow
+import itsdangerous
+import time
+
+
+@hookimpl
+def register_permissions():
+    return (
+        Permission(
+            name="view-instance",
+            abbr="vi",
+            description="View Datasette instance",
+            takes_database=False,
+            takes_resource=False,
+            default=True,
+        ),
+        Permission(
+            name="view-database",
+            abbr="vd",
+            description="View database",
+            takes_database=True,
+            takes_resource=False,
+            default=True,
+            implies_can_view=True,
+        ),
+        Permission(
+            name="view-database-download",
+            abbr="vdd",
+            description="Download database file",
+            takes_database=True,
+            takes_resource=False,
+            default=True,
+        ),
+        Permission(
+            name="view-table",
+            abbr="vt",
+            description="View table",
+            takes_database=True,
+            takes_resource=True,
+            default=True,
+            implies_can_view=True,
+        ),
+        Permission(
+            name="view-query",
+            abbr="vq",
+            description="View named query results",
+            takes_database=True,
+            takes_resource=True,
+            default=True,
+            implies_can_view=True,
+        ),
+        Permission(
+            name="execute-sql",
+            abbr="es",
+            description="Execute read-only SQL queries",
+            takes_database=True,
+            takes_resource=False,
+            default=True,
+            implies_can_view=True,
+        ),
+        Permission(
+            name="permissions-debug",
+            abbr="pd",
+            description="Access permission debug tool",
+            takes_database=False,
+            takes_resource=False,
+            default=False,
+        ),
+        Permission(
+            name="debug-menu",
+            abbr="dm",
+            description="View debug menu items",
+            takes_database=False,
+            takes_resource=False,
+            default=False,
+        ),
+        Permission(
+            name="insert-row",
+            abbr="ir",
+            description="Insert rows",
+            takes_database=True,
+            takes_resource=True,
+            default=False,
+        ),
+        Permission(
+            name="delete-row",
+            abbr="dr",
+            description="Delete rows",
+            takes_database=True,
+            takes_resource=True,
+            default=False,
+        ),
+        Permission(
+            name="update-row",
+            abbr="ur",
+            description="Update rows",
+            takes_database=True,
+            takes_resource=True,
+            default=False,
+        ),
+        Permission(
+            name="create-table",
+            abbr="ct",
+            description="Create tables",
+            takes_database=True,
+            takes_resource=False,
+            default=False,
+        ),
+        Permission(
+            name="alter-table",
+            abbr="at",
+            description="Alter tables",
+            takes_database=True,
+            takes_resource=True,
+            default=False,
+        ),
+        Permission(
+            name="drop-table",
+            abbr="dt",
+            description="Drop tables",
+            takes_database=True,
+            takes_resource=True,
+            default=False,
+        ),
+    )
+
+
+@hookimpl(tryfirst=True, specname="permission_allowed")
+def permission_allowed_default(datasette, actor, action, resource):
+    async def inner():
+        # id=root gets some special permissions:
+        if action in (
+            "permissions-debug",
+            "debug-menu",
+            "insert-row",
+            "create-table",
+            "alter-table",
+            "drop-table",
+            "delete-row",
+            "update-row",
+        ):
+            if actor and actor.get("id") == "root":
+                return True
+
+        # Resolve view permissions in allow blocks in configuration
+        if action in (
+            "view-instance",
+            "view-database",
+            "view-table",
+            "view-query",
+            "execute-sql",
+        ):
+            result = await _resolve_config_view_permissions(
+                datasette, actor, action, resource
+            )
+            if result is not None:
+                return result
+
+        # Resolve custom permissions: blocks in configuration
+        result = await _resolve_config_permissions_blocks(
+            datasette, actor, action, resource
+        )
+        if result is not None:
+            return result
+
+        # --setting default_allow_sql
+        if action == "execute-sql" and not datasette.setting("default_allow_sql"):
+            return False
+
+    return inner
+
+
+@hookimpl
+async def permission_resources_sql(datasette, actor, action):
+    rules: list[PluginSQL] = []
+
+    config_rules = await _config_permission_rules(datasette, actor, action)
+    rules.extend(config_rules)
+
+    default_allow_actions = {
+        "view-instance",
+        "view-database",
+        "view-table",
+        "execute-sql",
+    }
+    if action in default_allow_actions:
+        reason = f"default allow for {action}".replace("'", "''")
+        sql = (
+            "SELECT NULL AS parent, NULL AS child, 1 AS allow, " f"'{reason}' AS reason"
+        )
+        rules.append(
+            PluginSQL(
+                source="default_permissions",
+                sql=sql,
+                params={},
+            )
+        )
+
+    if not rules:
+        return None
+    if len(rules) == 1:
+        return rules[0]
+    return rules
+
+
+async def _config_permission_rules(datasette, actor, action) -> list[PluginSQL]:
+    config = datasette.config or {}
+
+    if actor is None:
+        actor_dict: dict | None = None
+    elif isinstance(actor, dict):
+        actor_dict = actor
+    else:
+        actor_lookup = await datasette.actors_from_ids([actor])
+        actor_dict = actor_lookup.get(actor) or {"id": actor}
+
+    def evaluate(allow_block):
+        if allow_block is None:
+            return None
+        return actor_matches_allow(actor_dict, allow_block)
+
+    rows = []
+
+    def add_row(parent, child, result, scope):
+        if result is None:
+            return
+        rows.append(
+            (
+                parent,
+                child,
+                bool(result),
+                f"config {'allow' if result else 'deny'} {scope}",
+            )
+        )
+
+    root_perm = (config.get("permissions") or {}).get(action)
+    add_row(None, None, evaluate(root_perm), f"permissions for {action}")
+
+    for db_name, db_config in (config.get("databases") or {}).items():
+        db_perm = (db_config.get("permissions") or {}).get(action)
+        add_row(
+            db_name, None, evaluate(db_perm), f"permissions for {action} on {db_name}"
+        )
+
+        for table_name, table_config in (db_config.get("tables") or {}).items():
+            table_perm = (table_config.get("permissions") or {}).get(action)
+            add_row(
+                db_name,
+                table_name,
+                evaluate(table_perm),
+                f"permissions for {action} on {db_name}/{table_name}",
+            )
+
+            if action == "view-table":
+                table_allow = (table_config or {}).get("allow")
+                add_row(
+                    db_name,
+                    table_name,
+                    evaluate(table_allow),
+                    f"allow for {action} on {db_name}/{table_name}",
+                )
+
+        for query_name, query_config in (db_config.get("queries") or {}).items():
+            query_perm = (query_config.get("permissions") or {}).get(action)
+            add_row(
+                db_name,
+                query_name,
+                evaluate(query_perm),
+                f"permissions for {action} on {db_name}/{query_name}",
+            )
+            if action == "view-query":
+                query_allow = (query_config or {}).get("allow")
+                add_row(
+                    db_name,
+                    query_name,
+                    evaluate(query_allow),
+                    f"allow for {action} on {db_name}/{query_name}",
+                )
+
+        if action == "view-database":
+            db_allow = db_config.get("allow")
+            add_row(
+                db_name, None, evaluate(db_allow), f"allow for {action} on {db_name}"
+            )
+
+        if action == "execute-sql":
+            db_allow_sql = db_config.get("allow_sql")
+            add_row(db_name, None, evaluate(db_allow_sql), f"allow_sql for {db_name}")
+
+    if action == "view-instance":
+        allow_block = config.get("allow")
+        add_row(None, None, evaluate(allow_block), "allow for view-instance")
+
+    if action == "view-table":
+        # Tables handled in loop
+        pass
+
+    if action == "view-query":
+        # Queries handled in loop
+        pass
+
+    if action == "execute-sql":
+        allow_sql = config.get("allow_sql")
+        add_row(None, None, evaluate(allow_sql), "allow_sql")
+
+    if action == "view-database":
+        # already handled per-database
+        pass
+
+    if not rows:
+        return []
+
+    parts = []
+    params = {}
+    for idx, (parent, child, allow, reason) in enumerate(rows):
+        key = f"cfg_{idx}"
+        parts.append(
+            f"SELECT :{key}_parent AS parent, :{key}_child AS child, :{key}_allow AS allow, :{key}_reason AS reason"
+        )
+        params[f"{key}_parent"] = parent
+        params[f"{key}_child"] = child
+        params[f"{key}_allow"] = 1 if allow else 0
+        params[f"{key}_reason"] = reason
+
+    sql = "\nUNION ALL\n".join(parts)
+    print(sql, params)
+    return [PluginSQL(source="config_permissions", sql=sql, params=params)]
+
+
+async def _resolve_config_permissions_blocks(datasette, actor, action, resource):
+    # Check custom permissions: blocks
+    config = datasette.config or {}
+    root_block = (config.get("permissions", None) or {}).get(action)
+    if root_block:
+        root_result = actor_matches_allow(actor, root_block)
+        if root_result is not None:
+            return root_result
+    # Now try database-specific blocks
+    if not resource:
+        return None
+    if isinstance(resource, str):
+        database = resource
+    else:
+        database = resource[0]
+    database_block = (
+        (config.get("databases", {}).get(database, {}).get("permissions", None)) or {}
+    ).get(action)
+    if database_block:
+        database_result = actor_matches_allow(actor, database_block)
+        if database_result is not None:
+            return database_result
+    # Finally try table/query specific blocks
+    if not isinstance(resource, tuple):
+        return None
+    database, table_or_query = resource
+    table_block = (
+        (
+            config.get("databases", {})
+            .get(database, {})
+            .get("tables", {})
+            .get(table_or_query, {})
+            .get("permissions", None)
+        )
+        or {}
+    ).get(action)
+    if table_block:
+        table_result = actor_matches_allow(actor, table_block)
+        if table_result is not None:
+            return table_result
+    # Finally the canned queries
+    query_block = (
+        (
+            config.get("databases", {})
+            .get(database, {})
+            .get("queries", {})
+            .get(table_or_query, {})
+            .get("permissions", None)
+        )
+        or {}
+    ).get(action)
+    if query_block:
+        query_result = actor_matches_allow(actor, query_block)
+        if query_result is not None:
+            return query_result
+    return None
+
+
+async def _resolve_config_view_permissions(datasette, actor, action, resource):
+    config = datasette.config or {}
+    if action == "view-instance":
+        allow = config.get("allow")
+        if allow is not None:
+            return actor_matches_allow(actor, allow)
+    elif action == "view-database":
+        database_allow = ((config.get("databases") or {}).get(resource) or {}).get(
+            "allow"
+        )
+        if database_allow is None:
+            return None
+        return actor_matches_allow(actor, database_allow)
+    elif action == "view-table":
+        database, table = resource
+        tables = ((config.get("databases") or {}).get(database) or {}).get(
+            "tables"
+        ) or {}
+        table_allow = (tables.get(table) or {}).get("allow")
+        if table_allow is None:
+            return None
+        return actor_matches_allow(actor, table_allow)
+    elif action == "view-query":
+        # Check if this query has a "allow" block in config
+        database, query_name = resource
+        query = await datasette.get_canned_query(database, query_name, actor)
+        assert query is not None
+        allow = query.get("allow")
+        if allow is None:
+            return None
+        return actor_matches_allow(actor, allow)
+    elif action == "execute-sql":
+        # Use allow_sql block from database block, or from top-level
+        database_allow_sql = ((config.get("databases") or {}).get(resource) or {}).get(
+            "allow_sql"
+        )
+        if database_allow_sql is None:
+            database_allow_sql = config.get("allow_sql")
+        if database_allow_sql is None:
+            return None
+        return actor_matches_allow(actor, database_allow_sql)
+
+
+def restrictions_allow_action(
+    datasette: "Datasette",
+    restrictions: dict,
+    action: str,
+    resource: str | tuple[str, str],
+):
+    "Do these restrictions allow the requested action against the requested resource?"
+    if action == "view-instance":
+        # Special case for view-instance: it's allowed if the restrictions include any
+        # permissions that have the implies_can_view=True flag set
+        all_rules = restrictions.get("a") or []
+        for database_rules in (restrictions.get("d") or {}).values():
+            all_rules += database_rules
+        for database_resource_rules in (restrictions.get("r") or {}).values():
+            for resource_rules in database_resource_rules.values():
+                all_rules += resource_rules
+        permissions = [datasette.get_permission(action) for action in all_rules]
+        if any(p for p in permissions if p.implies_can_view):
+            return True
+
+    if action == "view-database":
+        # Special case for view-database: it's allowed if the restrictions include any
+        # permissions that have the implies_can_view=True flag set AND takes_database
+        all_rules = restrictions.get("a") or []
+        database_rules = list((restrictions.get("d") or {}).get(resource) or [])
+        all_rules += database_rules
+        resource_rules = ((restrictions.get("r") or {}).get(resource) or {}).values()
+        for resource_rules in (restrictions.get("r") or {}).values():
+            for table_rules in resource_rules.values():
+                all_rules += table_rules
+        permissions = [datasette.get_permission(action) for action in all_rules]
+        if any(p for p in permissions if p.implies_can_view and p.takes_database):
+            return True
+
+    # Does this action have an abbreviation?
+    to_check = {action}
+    permission = datasette.permissions.get(action)
+    if permission and permission.abbr:
+        to_check.add(permission.abbr)
+
+    # If restrictions is defined then we use those to further restrict the actor
+    # Crucially, we only use this to say NO (return False) - we never
+    # use it to return YES (True) because that might over-ride other
+    # restrictions placed on this actor
+    all_allowed = restrictions.get("a")
+    if all_allowed is not None:
+        assert isinstance(all_allowed, list)
+        if to_check.intersection(all_allowed):
+            return True
+    # How about for the current database?
+    if resource:
+        if isinstance(resource, str):
+            database_name = resource
+        else:
+            database_name = resource[0]
+        database_allowed = restrictions.get("d", {}).get(database_name)
+        if database_allowed is not None:
+            assert isinstance(database_allowed, list)
+            if to_check.intersection(database_allowed):
+                return True
+    # Or the current table? That's any time the resource is (database, table)
+    if resource is not None and not isinstance(resource, str) and len(resource) == 2:
+        database, table = resource
+        table_allowed = restrictions.get("r", {}).get(database, {}).get(table)
+        # TODO: What should this do for canned queries?
+        if table_allowed is not None:
+            assert isinstance(table_allowed, list)
+            if to_check.intersection(table_allowed):
+                return True
+
+    # This action is not specifically allowed, so reject it
+    return False
+
+
+@hookimpl(specname="permission_allowed")
+def permission_allowed_actor_restrictions(datasette, actor, action, resource):
+    if actor is None:
+        return None
+    if "_r" not in actor:
+        # No restrictions, so we have no opinion
+        return None
+    _r = actor.get("_r")
+    if restrictions_allow_action(datasette, _r, action, resource):
+        # Return None because we do not have an opinion here
+        return None
+    else:
+        # Block this permission check
+        return False
+
+
+@hookimpl
+def actor_from_request(datasette, request):
+    prefix = "dstok_"
+    if not datasette.setting("allow_signed_tokens"):
+        return None
+    max_signed_tokens_ttl = datasette.setting("max_signed_tokens_ttl")
+    authorization = request.headers.get("authorization")
+    if not authorization:
+        return None
+    if not authorization.startswith("Bearer "):
+        return None
+    token = authorization[len("Bearer ") :]
+    if not token.startswith(prefix):
+        return None
+    token = token[len(prefix) :]
+    try:
+        decoded = datasette.unsign(token, namespace="token")
+    except itsdangerous.BadSignature:
+        return None
+    if "t" not in decoded:
+        # Missing timestamp
+        return None
+    created = decoded["t"]
+    if not isinstance(created, int):
+        # Invalid timestamp
+        return None
+    duration = decoded.get("d")
+    if duration is not None and not isinstance(duration, int):
+        # Invalid duration
+        return None
+    if (duration is None and max_signed_tokens_ttl) or (
+        duration is not None
+        and max_signed_tokens_ttl
+        and duration > max_signed_tokens_ttl
+    ):
+        duration = max_signed_tokens_ttl
+    if duration:
+        if time.time() - created > duration:
+            # Expired
+            return None
+    actor = {"id": decoded["a"], "token": "dstok"}
+    if "_r" in decoded:
+        actor["_r"] = decoded["_r"]
+    if duration:
+        actor["token_expires"] = created + duration
+    return actor
+
+
+@hookimpl
+def skip_csrf(scope):
+    # Skip CSRF check for requests with content-type: application/json
+    if scope["type"] == "http":
+        headers = scope.get("headers") or {}
+        if dict(headers).get(b"content-type") == b"application/json":
+            return True

datasette/default_permissions/__init__.py

@@ -1,34 +0,0 @@
-"""
-Default permission implementations for Datasette.
-
-This module provides the built-in permission checking logic through implementations
-of the permission_resources_sql hook. The hooks are organized by their purpose:
-
-1. Actor Restrictions - Enforces _r allowlists embedded in actor tokens
-2. Root User - Grants full access when --root flag is used
-3. Config Rules - Applies permissions from datasette.yaml
-4. Default Settings - Enforces default_allow_sql and default view permissions
-
-IMPORTANT: These hooks return PermissionSQL objects that are combined using SQL
-UNION/INTERSECT operations. The order of evaluation is:
-  - restriction_sql fields are INTERSECTed (all must match)
-  - Regular sql fields are UNIONed and evaluated with cascading priority
-"""
-
-from __future__ import annotations
-
-# Re-export all hooks and public utilities
-from .restrictions import (
-    actor_restrictions_sql as actor_restrictions_sql,
-    restrictions_allow_action as restrictions_allow_action,
-    ActorRestrictions as ActorRestrictions,
-)
-from .root import root_user_permissions_sql as root_user_permissions_sql
-from .config import config_permissions_sql as config_permissions_sql
-from .defaults import (
-    # Avoid "datasette.default_permissions" does not explicitly export attribute
-    default_allow_sql_check as default_allow_sql_check,
-    default_action_permissions_sql as default_action_permissions_sql,
-    default_query_permissions_sql as default_query_permissions_sql,
-    DEFAULT_ALLOW_ACTIONS as DEFAULT_ALLOW_ACTIONS,
-)

datasette/default_permissions/config.py

@@ -1,442 +0,0 @@
-"""
-Config-based permission handling for Datasette.
-
-Applies permission rules from datasette.yaml configuration.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Any, List, Optional, Set, Tuple
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette import hookimpl
-from datasette.permissions import PermissionSQL
-from datasette.utils import actor_matches_allow
-
-from .helpers import PermissionRowCollector, get_action_name_variants
-
-
-class ConfigPermissionProcessor:
-    """
-    Processes permission rules from datasette.yaml configuration.
-
-    Configuration structure:
-
-    permissions:                    # Root-level permissions block
-      view-instance:
-        id: admin
-
-    databases:
-      mydb:
-        permissions:                # Database-level permissions
-          view-database:
-            id: admin
-        allow:                      # Database-level allow block (for view-*)
-          id: viewer
-        allow_sql:                  # execute-sql allow block
-          id: analyst
-        tables:
-          users:
-            permissions:            # Table-level permissions
-              view-table:
-                id: admin
-            allow:                  # Table-level allow block
-              id: viewer
-        queries:
-          my_query:
-            permissions:            # Query-level permissions
-              view-query:
-                id: admin
-            allow:                  # Query-level allow block
-              id: viewer
-    """
-
-    def __init__(
-        self,
-        datasette: "Datasette",
-        actor: Optional[dict],
-        action: str,
-    ):
-        self.datasette = datasette
-        self.actor = actor
-        self.action = action
-        self.config = datasette.config or {}
-        self.collector = PermissionRowCollector(prefix="cfg")
-
-        # Pre-compute action variants
-        self.action_checks = get_action_name_variants(datasette, action)
-        self.action_obj = datasette.actions.get(action)
-
-        # Parse restrictions if present
-        self.has_restrictions = actor and "_r" in actor if actor else False
-        self.restrictions = actor.get("_r", {}) if actor else {}
-
-        # Pre-compute restriction info for efficiency
-        self.restricted_databases: Set[str] = set()
-        self.restricted_tables: Set[Tuple[str, str]] = set()
-
-        if self.has_restrictions:
-            self.restricted_databases = {
-                db_name
-                for db_name, db_actions in (self.restrictions.get("d") or {}).items()
-                if self.action_checks.intersection(db_actions)
-            }
-            self.restricted_tables = {
-                (db_name, table_name)
-                for db_name, tables in (self.restrictions.get("r") or {}).items()
-                for table_name, table_actions in tables.items()
-                if self.action_checks.intersection(table_actions)
-            }
-            # Tables implicitly reference their parent databases
-            self.restricted_databases.update(db for db, _ in self.restricted_tables)
-
-    def evaluate_allow_block(self, allow_block: Any) -> Optional[bool]:
-        """Evaluate an allow block against the current actor."""
-        if allow_block is None:
-            return None
-        return actor_matches_allow(self.actor, allow_block)
-
-    def is_in_restriction_allowlist(
-        self,
-        parent: Optional[str],
-        child: Optional[str],
-    ) -> bool:
-        """Check if resource is allowed by actor restrictions."""
-        if not self.has_restrictions:
-            return True  # No restrictions, all resources allowed
-
-        # Check global allowlist
-        if self.action_checks.intersection(self.restrictions.get("a", [])):
-            return True
-
-        # Check database-level allowlist
-        if parent and self.action_checks.intersection(
-            self.restrictions.get("d", {}).get(parent, [])
-        ):
-            return True
-
-        # Check table-level allowlist
-        if parent:
-            table_restrictions = (self.restrictions.get("r", {}) or {}).get(parent, {})
-            if child:
-                table_actions = table_restrictions.get(child, [])
-                if self.action_checks.intersection(table_actions):
-                    return True
-            else:
-                # Parent query should proceed if any child in this database is allowlisted
-                for table_actions in table_restrictions.values():
-                    if self.action_checks.intersection(table_actions):
-                        return True
-
-        # Parent/child both None: include if any restrictions exist for this action
-        if parent is None and child is None:
-            if self.action_checks.intersection(self.restrictions.get("a", [])):
-                return True
-            if self.restricted_databases:
-                return True
-            if self.restricted_tables:
-                return True
-
-        return False
-
-    def add_permissions_rule(
-        self,
-        parent: Optional[str],
-        child: Optional[str],
-        permissions_block: Optional[dict],
-        scope_desc: str,
-    ) -> None:
-        """Add a rule from a permissions:{action} block."""
-        if permissions_block is None:
-            return
-
-        action_allow_block = permissions_block.get(self.action)
-        result = self.evaluate_allow_block(action_allow_block)
-
-        self.collector.add(
-            parent=parent,
-            child=child,
-            allow=result,
-            reason=f"config {'allow' if result else 'deny'} {scope_desc}",
-            if_not_none=True,
-        )
-
-    def add_allow_block_rule(
-        self,
-        parent: Optional[str],
-        child: Optional[str],
-        allow_block: Any,
-        scope_desc: str,
-    ) -> None:
-        """
-        Add rules from an allow:{} block.
-
-        For allow blocks, if the block exists but doesn't match the actor,
-        this is treated as a deny. We also handle the restriction-gate logic.
-        """
-        if allow_block is None:
-            return
-
-        # Skip if resource is not in restriction allowlist
-        if not self.is_in_restriction_allowlist(parent, child):
-            return
-
-        result = self.evaluate_allow_block(allow_block)
-        bool_result = bool(result)
-
-        self.collector.add(
-            parent,
-            child,
-            bool_result,
-            f"config {'allow' if result else 'deny'} {scope_desc}",
-        )
-
-        # Handle restriction-gate: add explicit denies for restricted resources
-        self._add_restriction_gate_denies(parent, child, bool_result, scope_desc)
-
-    def _add_restriction_gate_denies(
-        self,
-        parent: Optional[str],
-        child: Optional[str],
-        is_allowed: bool,
-        scope_desc: str,
-    ) -> None:
-        """
-        When a config rule denies at a higher level, add explicit denies
-        for restricted resources to prevent child-level allows from
-        incorrectly granting access.
-        """
-        if is_allowed or child is not None or not self.has_restrictions:
-            return
-
-        if not self.action_obj:
-            return
-
-        reason = f"config deny {scope_desc} (restriction gate)"
-
-        if parent is None:
-            # Root-level deny: add denies for all restricted resources
-            if self.action_obj.takes_parent:
-                for db_name in self.restricted_databases:
-                    self.collector.add(db_name, None, False, reason)
-            if self.action_obj.takes_child:
-                for db_name, table_name in self.restricted_tables:
-                    self.collector.add(db_name, table_name, False, reason)
-        else:
-            # Database-level deny: add denies for tables in that database
-            if self.action_obj.takes_child:
-                for db_name, table_name in self.restricted_tables:
-                    if db_name == parent:
-                        self.collector.add(db_name, table_name, False, reason)
-
-    def process(self) -> Optional[PermissionSQL]:
-        """Process all config rules and return combined PermissionSQL."""
-        self._process_root_permissions()
-        self._process_databases()
-        self._process_root_allow_blocks()
-
-        return self.collector.to_permission_sql()
-
-    def _process_root_permissions(self) -> None:
-        """Process root-level permissions block."""
-        root_perms = self.config.get("permissions") or {}
-        self.add_permissions_rule(
-            None,
-            None,
-            root_perms,
-            f"permissions for {self.action}",
-        )
-
-    def _process_databases(self) -> None:
-        """Process database-level and nested configurations."""
-        databases = self.config.get("databases") or {}
-
-        for db_name, db_config in databases.items():
-            self._process_database(db_name, db_config or {})
-
-    def _process_database(self, db_name: str, db_config: dict) -> None:
-        """Process a single database's configuration."""
-        # Database-level permissions block
-        db_perms = db_config.get("permissions") or {}
-        self.add_permissions_rule(
-            db_name,
-            None,
-            db_perms,
-            f"permissions for {self.action} on {db_name}",
-        )
-
-        # Process tables
-        for table_name, table_config in (db_config.get("tables") or {}).items():
-            self._process_table(db_name, table_name, table_config or {})
-
-        # Process queries
-        for query_name, query_config in (db_config.get("queries") or {}).items():
-            self._process_query(db_name, query_name, query_config)
-
-        # Database-level allow blocks
-        self._process_database_allow_blocks(db_name, db_config)
-
-    def _process_table(
-        self,
-        db_name: str,
-        table_name: str,
-        table_config: dict,
-    ) -> None:
-        """Process a single table's configuration."""
-        # Table-level permissions block
-        table_perms = table_config.get("permissions") or {}
-        self.add_permissions_rule(
-            db_name,
-            table_name,
-            table_perms,
-            f"permissions for {self.action} on {db_name}/{table_name}",
-        )
-
-        # Table-level allow block (for view-table)
-        if self.action == "view-table":
-            self.add_allow_block_rule(
-                db_name,
-                table_name,
-                table_config.get("allow"),
-                f"allow for {self.action} on {db_name}/{table_name}",
-            )
-
-    def _process_query(
-        self,
-        db_name: str,
-        query_name: str,
-        query_config: Any,
-    ) -> None:
-        """Process a single query's configuration."""
-        # Query config can be a string (just SQL) or dict
-        if not isinstance(query_config, dict):
-            return
-
-        # Query-level permissions block
-        query_perms = query_config.get("permissions") or {}
-        self.add_permissions_rule(
-            db_name,
-            query_name,
-            query_perms,
-            f"permissions for {self.action} on {db_name}/{query_name}",
-        )
-
-        # Query-level allow block (for view-query)
-        if self.action == "view-query":
-            self.add_allow_block_rule(
-                db_name,
-                query_name,
-                query_config.get("allow"),
-                f"allow for {self.action} on {db_name}/{query_name}",
-            )
-
-    def _process_database_allow_blocks(
-        self,
-        db_name: str,
-        db_config: dict,
-    ) -> None:
-        """Process database-level allow/allow_sql blocks."""
-        # view-database allow block
-        if self.action == "view-database":
-            self.add_allow_block_rule(
-                db_name,
-                None,
-                db_config.get("allow"),
-                f"allow for {self.action} on {db_name}",
-            )
-
-        # execute-sql allow_sql block
-        if self.action == "execute-sql":
-            self.add_allow_block_rule(
-                db_name,
-                None,
-                db_config.get("allow_sql"),
-                f"allow_sql for {db_name}",
-            )
-
-        # view-table uses database-level allow for inheritance
-        if self.action == "view-table":
-            self.add_allow_block_rule(
-                db_name,
-                None,
-                db_config.get("allow"),
-                f"allow for {self.action} on {db_name}",
-            )
-
-        # view-query uses database-level allow for inheritance
-        if self.action == "view-query":
-            self.add_allow_block_rule(
-                db_name,
-                None,
-                db_config.get("allow"),
-                f"allow for {self.action} on {db_name}",
-            )
-
-    def _process_root_allow_blocks(self) -> None:
-        """Process root-level allow/allow_sql blocks."""
-        root_allow = self.config.get("allow")
-
-        if self.action == "view-instance":
-            self.add_allow_block_rule(
-                None,
-                None,
-                root_allow,
-                "allow for view-instance",
-            )
-
-        if self.action == "view-database":
-            self.add_allow_block_rule(
-                None,
-                None,
-                root_allow,
-                "allow for view-database",
-            )
-
-        if self.action == "view-table":
-            self.add_allow_block_rule(
-                None,
-                None,
-                root_allow,
-                "allow for view-table",
-            )
-
-        if self.action == "view-query":
-            self.add_allow_block_rule(
-                None,
-                None,
-                root_allow,
-                "allow for view-query",
-            )
-
-        if self.action == "execute-sql":
-            self.add_allow_block_rule(
-                None,
-                None,
-                self.config.get("allow_sql"),
-                "allow_sql",
-            )
-
-
-@hookimpl(specname="permission_resources_sql")
-async def config_permissions_sql(
-    datasette: "Datasette",
-    actor: Optional[dict],
-    action: str,
-) -> Optional[List[PermissionSQL]]:
-    """
-    Apply permission rules from datasette.yaml configuration.
-
-    This processes:
-    - permissions: blocks at root, database, table, and query levels
-    - allow: blocks for view-* actions
-    - allow_sql: blocks for execute-sql action
-    """
-    processor = ConfigPermissionProcessor(datasette, actor, action)
-    result = processor.process()
-
-    if result is None:
-        return []
-
-    return [result]

datasette/default_permissions/defaults.py

@@ -1,114 +0,0 @@
-"""
-Default permission settings for Datasette.
-
-Provides default allow rules for standard view/execute actions.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette import hookimpl
-from datasette.permissions import PermissionSQL
-
-# Actions that are allowed by default (unless --default-deny is used)
-DEFAULT_ALLOW_ACTIONS = frozenset(
-    {
-        "view-instance",
-        "view-database",
-        "view-database-download",
-        "view-table",
-        "view-query",
-        "execute-sql",
-    }
-)
-
-
-@hookimpl(specname="permission_resources_sql")
-async def default_allow_sql_check(
-    datasette: "Datasette",
-    actor: Optional[dict],
-    action: str,
-) -> Optional[PermissionSQL]:
-    """
-    Enforce the default_allow_sql setting.
-
-    When default_allow_sql is false (the default), execute-sql is denied
-    unless explicitly allowed by config or other rules.
-    """
-    if action == "execute-sql":
-        if not datasette.setting("default_allow_sql"):
-            return PermissionSQL.deny(reason="default_allow_sql is false")
-
-    return None
-
-
-@hookimpl(specname="permission_resources_sql")
-async def default_action_permissions_sql(
-    datasette: "Datasette",
-    actor: Optional[dict],
-    action: str,
-) -> Optional[PermissionSQL]:
-    """
-    Provide default allow rules for standard view/execute actions.
-
-    These defaults are skipped when datasette is started with --default-deny.
-    The restriction_sql mechanism (from actor_restrictions_sql) will still
-    filter these results if the actor has restrictions.
-    """
-    if datasette.default_deny:
-        return None
-
-    if action in DEFAULT_ALLOW_ACTIONS:
-        reason = f"default allow for {action}".replace("'", "''")
-        return PermissionSQL.allow(reason=reason)
-
-    return None
-
-
-@hookimpl(specname="permission_resources_sql")
-async def default_query_permissions_sql(
-    datasette: "Datasette",
-    actor: Optional[dict],
-    action: str,
-) -> Optional[PermissionSQL]:
-    actor_id = actor.get("id") if isinstance(actor, dict) else None
-
-    if action not in {"view-query", "update-query", "delete-query"}:
-        return None
-
-    params = {"query_owner_id": actor_id}
-    rule_sqls = []
-    if actor_id is not None:
-        if action in {"update-query", "delete-query"}:
-            # Query owner can update/delete query
-            rule_sqls.append("""
-            SELECT database_name AS parent, name AS child, 1 AS allow,
-              'query owner' AS reason
-            FROM queries
-            WHERE source = 'user'
-              AND owner_id = :query_owner_id
-            """)
-        else:
-            # Query owner can view-query
-            rule_sqls.append("""
-            SELECT database_name AS parent, name AS child, 1 AS allow,
-              'query owner' AS reason
-            FROM queries
-            WHERE owner_id = :query_owner_id
-            """)
-
-    # restriction_sql enforces private queries ONLY visible/mutable by owner
-    return PermissionSQL(
-        sql="\nUNION ALL\n".join(rule_sqls) if rule_sqls else None,
-        restriction_sql="""
-        SELECT database_name AS parent, name AS child
-        FROM queries
-        WHERE is_private = 0
-           OR owner_id = :query_owner_id
-        """,
-        params=params,
-    )

datasette/default_permissions/helpers.py

@@ -1,85 +0,0 @@
-"""
-Shared helper utilities for default permission implementations.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional, Set
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette.permissions import PermissionSQL
-
-
-def get_action_name_variants(datasette: "Datasette", action: str) -> Set[str]:
-    """
-    Get all name variants for an action (full name and abbreviation).
-
-    Example:
-        get_action_name_variants(ds, "view-table") -> {"view-table", "vt"}
-    """
-    variants = {action}
-    action_obj = datasette.actions.get(action)
-    if action_obj and action_obj.abbr:
-        variants.add(action_obj.abbr)
-    return variants
-
-
-def action_in_list(datasette: "Datasette", action: str, action_list: list) -> bool:
-    """Check if an action (or its abbreviation) is in a list."""
-    return bool(get_action_name_variants(datasette, action).intersection(action_list))
-
-
-@dataclass
-class PermissionRow:
-    """A single permission rule row."""
-
-    parent: Optional[str]
-    child: Optional[str]
-    allow: bool
-    reason: str
-
-
-class PermissionRowCollector:
-    """Collects permission rows and converts them to PermissionSQL."""
-
-    def __init__(self, prefix: str = "row"):
-        self.rows: List[PermissionRow] = []
-        self.prefix = prefix
-
-    def add(
-        self,
-        parent: Optional[str],
-        child: Optional[str],
-        allow: Optional[bool],
-        reason: str,
-        if_not_none: bool = False,
-    ) -> None:
-        """Add a permission row. If if_not_none=True, only add if allow is not None."""
-        if if_not_none and allow is None:
-            return
-        self.rows.append(PermissionRow(parent, child, allow, reason))
-
-    def to_permission_sql(self) -> Optional[PermissionSQL]:
-        """Convert collected rows to a PermissionSQL object."""
-        if not self.rows:
-            return None
-
-        parts = []
-        params = {}
-
-        for idx, row in enumerate(self.rows):
-            key = f"{self.prefix}_{idx}"
-            parts.append(
-                f"SELECT :{key}_parent AS parent, :{key}_child AS child, "
-                f":{key}_allow AS allow, :{key}_reason AS reason"
-            )
-            params[f"{key}_parent"] = row.parent
-            params[f"{key}_child"] = row.child
-            params[f"{key}_allow"] = 1 if row.allow else 0
-            params[f"{key}_reason"] = row.reason
-
-        sql = "\nUNION ALL\n".join(parts)
-        return PermissionSQL(sql=sql, params=params)

datasette/default_permissions/restrictions.py

@@ -1,195 +0,0 @@
-"""
-Actor restriction handling for Datasette permissions.
-
-This module handles the _r (restrictions) key in actor dictionaries, which
-contains allowlists of resources the actor can access.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, List, Optional, Set, Tuple
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette import hookimpl
-from datasette.permissions import PermissionSQL
-
-from .helpers import action_in_list, get_action_name_variants
-
-
-@dataclass
-class ActorRestrictions:
-    """Parsed actor restrictions from the _r key."""
-
-    global_actions: List[str]  # _r.a - globally allowed actions
-    database_actions: dict  # _r.d - {db_name: [actions]}
-    table_actions: dict  # _r.r - {db_name: {table: [actions]}}
-
-    @classmethod
-    def from_actor(cls, actor: Optional[dict]) -> Optional["ActorRestrictions"]:
-        """Parse restrictions from actor dict. Returns None if no restrictions."""
-        if not actor:
-            return None
-        assert isinstance(actor, dict), "actor must be a dictionary"
-
-        restrictions = actor.get("_r")
-        if restrictions is None:
-            return None
-
-        return cls(
-            global_actions=restrictions.get("a", []),
-            database_actions=restrictions.get("d", {}),
-            table_actions=restrictions.get("r", {}),
-        )
-
-    def is_action_globally_allowed(self, datasette: "Datasette", action: str) -> bool:
-        """Check if action is in the global allowlist."""
-        return action_in_list(datasette, action, self.global_actions)
-
-    def get_allowed_databases(self, datasette: "Datasette", action: str) -> Set[str]:
-        """Get database names where this action is allowed."""
-        allowed = set()
-        for db_name, db_actions in self.database_actions.items():
-            if action_in_list(datasette, action, db_actions):
-                allowed.add(db_name)
-        return allowed
-
-    def get_allowed_tables(
-        self, datasette: "Datasette", action: str
-    ) -> Set[Tuple[str, str]]:
-        """Get (database, table) pairs where this action is allowed."""
-        allowed = set()
-        for db_name, tables in self.table_actions.items():
-            for table_name, table_actions in tables.items():
-                if action_in_list(datasette, action, table_actions):
-                    allowed.add((db_name, table_name))
-        return allowed
-
-
-@hookimpl(specname="permission_resources_sql")
-async def actor_restrictions_sql(
-    datasette: "Datasette",
-    actor: Optional[dict],
-    action: str,
-) -> Optional[List[PermissionSQL]]:
-    """
-    Handle actor restriction-based permission rules.
-
-    When an actor has an "_r" key, it contains an allowlist of resources they
-    can access. This function returns restriction_sql that filters the final
-    results to only include resources in that allowlist.
-
-    The _r structure:
-    {
-        "a": ["vi", "pd"],           # Global actions allowed
-        "d": {"mydb": ["vt", "es"]}, # Database-level actions
-        "r": {"mydb": {"users": ["vt"]}}  # Table-level actions
-    }
-    """
-    if not actor:
-        return None
-
-    restrictions = ActorRestrictions.from_actor(actor)
-
-    if restrictions is None:
-        # No restrictions - all resources allowed
-        return []
-
-    # If globally allowed, no filtering needed
-    if restrictions.is_action_globally_allowed(datasette, action):
-        return []
-
-    # Build restriction SQL
-    allowed_dbs = restrictions.get_allowed_databases(datasette, action)
-    allowed_tables = restrictions.get_allowed_tables(datasette, action)
-
-    # If nothing is allowed for this action, return empty-set restriction
-    if not allowed_dbs and not allowed_tables:
-        return [
-            PermissionSQL(
-                params={"deny": f"actor restrictions: {action} not in allowlist"},
-                restriction_sql="SELECT NULL AS parent, NULL AS child WHERE 0",
-            )
-        ]
-
-    # Build UNION of allowed resources
-    selects = []
-    params = {}
-    counter = 0
-
-    # Database-level entries (parent, NULL) - allows all children
-    for db_name in allowed_dbs:
-        key = f"restr_{counter}"
-        counter += 1
-        selects.append(f"SELECT :{key}_parent AS parent, NULL AS child")
-        params[f"{key}_parent"] = db_name
-
-    # Table-level entries (parent, child)
-    for db_name, table_name in allowed_tables:
-        key = f"restr_{counter}"
-        counter += 1
-        selects.append(f"SELECT :{key}_parent AS parent, :{key}_child AS child")
-        params[f"{key}_parent"] = db_name
-        params[f"{key}_child"] = table_name
-
-    restriction_sql = "\nUNION ALL\n".join(selects)
-
-    return [PermissionSQL(params=params, restriction_sql=restriction_sql)]
-
-
-def restrictions_allow_action(
-    datasette: "Datasette",
-    restrictions: dict,
-    action: str,
-    resource: Optional[str | Tuple[str, str]],
-) -> bool:
-    """
-    Check if restrictions allow the requested action on the requested resource.
-
-    This is a synchronous utility function for use by other code that needs
-    to quickly check restriction allowlists.
-
-    Args:
-        datasette: The Datasette instance
-        restrictions: The _r dict from an actor
-        action: The action name to check
-        resource: None for global, str for database, (db, table) tuple for table
-
-    Returns:
-        True if allowed, False if denied
-    """
-    # Does this action have an abbreviation?
-    to_check = get_action_name_variants(datasette, action)
-
-    # Check global level (any resource)
-    all_allowed = restrictions.get("a")
-    if all_allowed is not None:
-        assert isinstance(all_allowed, list)
-        if to_check.intersection(all_allowed):
-            return True
-
-    # Check database level
-    if resource:
-        if isinstance(resource, str):
-            database_name = resource
-        else:
-            database_name = resource[0]
-        database_allowed = restrictions.get("d", {}).get(database_name)
-        if database_allowed is not None:
-            assert isinstance(database_allowed, list)
-            if to_check.intersection(database_allowed):
-                return True
-
-    # Check table/resource level
-    if resource is not None and not isinstance(resource, str) and len(resource) == 2:
-        database, table = resource
-        table_allowed = restrictions.get("r", {}).get(database, {}).get(table)
-        if table_allowed is not None:
-            assert isinstance(table_allowed, list)
-            if to_check.intersection(table_allowed):
-                return True
-
-    # This action is not explicitly allowed, so reject it
-    return False

datasette/default_permissions/root.py

@@ -1,29 +0,0 @@
-"""
-Root user permission handling for Datasette.
-
-Grants full permissions to the root user when --root flag is used.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette import hookimpl
-from datasette.permissions import PermissionSQL
-
-
-@hookimpl(specname="permission_resources_sql")
-async def root_user_permissions_sql(
-    datasette: "Datasette",
-    actor: Optional[dict],
-) -> Optional[PermissionSQL]:
-    """
-    Grant root user full permissions when --root flag is used.
-    """
-    if not datasette.root_enabled:
-        return None
-    if actor is not None and actor.get("id") == "root":
-        return PermissionSQL.allow(reason="root user")

datasette/default_permissions/tokens.py

@@ -1,40 +0,0 @@
-"""
-Token authentication for Datasette.
-
-Registers the default SignedTokenHandler and delegates token verification
-to datasette.verify_token() so all registered handlers are tried.
-"""
-
-from __future__ import annotations
-
-from typing import TYPE_CHECKING, Optional
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-from datasette import hookimpl
-from datasette.tokens import SignedTokenHandler
-
-
-@hookimpl
-def register_token_handler(datasette: "Datasette"):
-    """Register the default signed token handler."""
-    return SignedTokenHandler()
-
-
-@hookimpl(specname="actor_from_request")
-async def actor_from_signed_api_token(
-    datasette: "Datasette", request
-) -> Optional[dict]:
-    """
-    Authenticate requests using API tokens by delegating to all registered
-    token handlers via datasette.verify_token().
-    """
-    authorization = request.headers.get("authorization")
-    if not authorization:
-        return None
-    if not authorization.startswith("Bearer "):
-        return None
-
-    token = authorization[len("Bearer ") :]
-    return await datasette.verify_token(token)

datasette/events.py

@@ -2,6 +2,7 @@ from abc import ABC, abstractproperty
 from dataclasses import asdict, dataclass, field
 from datasette.hookspecs import hookimpl
 from datetime import datetime, timezone
+from typing import Optional
 
 
 @dataclass
@@ -13,7 +14,7 @@ class Event(ABC):
     created: datetime = field(
         init=False, default_factory=lambda: datetime.now(timezone.utc)
     )
-    actor: dict | None
+    actor: Optional[dict]
 
     def properties(self):
         properties = asdict(self)
@@ -62,7 +63,7 @@ class CreateTokenEvent(Event):
     """
 
     name = "create-token"
-    expires_after: int | None
+    expires_after: Optional[int]
     restrict_all: list
     restrict_database: dict
     restrict_resource: dict
@@ -199,27 +200,6 @@ class UpdateRowEvent(Event):
     pks: list
 
 
-@dataclass
-class RenameTableEvent(Event):
-    """
-    Event name: ``rename-table``
-
-    A table has been renamed.
-
-    :ivar database: The name of the database containing the renamed table.
-    :type database: str
-    :ivar old_table: The previous name of the table.
-    :type old_table: str
-    :ivar new_table: The new name of the table.
-    :type new_table: str
-    """
-
-    name = "rename-table"
-    database: str
-    old_table: str
-    new_table: str
-
-
 @dataclass
 class DeleteRowEvent(Event):
     """
@@ -240,42 +220,6 @@ class DeleteRowEvent(Event):
     pks: list
 
 
-@hookimpl
-def write_wrapper(datasette, database, request, transaction):
-    def wrapper(conn, track_event):
-        # Snapshot rootpage -> name before the write
-        before = {
-            row[1]: row[0]
-            for row in conn.execute(
-                "select name, rootpage from sqlite_master"
-                " where type='table' and rootpage != 0"
-            ).fetchall()
-        }
-        yield
-        # Snapshot rootpage -> name after the write
-        after = {
-            row[1]: row[0]
-            for row in conn.execute(
-                "select name, rootpage from sqlite_master"
-                " where type='table' and rootpage != 0"
-            ).fetchall()
-        }
-        # Detect renames: same rootpage, different name
-        for rootpage, old_name in before.items():
-            new_name = after.get(rootpage)
-            if new_name and new_name != old_name:
-                track_event(
-                    RenameTableEvent(
-                        actor=request.actor if request else None,
-                        database=database,
-                        old_table=old_name,
-                        new_table=new_name,
-                    )
-                )
-
-    return wrapper
-
-
 @hookimpl
 def register_events():
     return [
@@ -284,7 +228,6 @@ def register_events():
         CreateTableEvent,
         CreateTokenEvent,
         AlterTableEvent,
-        RenameTableEvent,
         DropTableEvent,
         InsertRowsEvent,
         UpsertRowsEvent,

datasette/facets.py

@@ -83,7 +83,7 @@ class Facet:
         self.ds = ds
         self.request = request
         self.database = database
-        # For foreign key expansion. Can be None for e.g. stored SQL queries:
+        # For foreign key expansion. Can be None for e.g. canned SQL queries:
         self.table = table
         self.sql = sql or f"select * from [{table}]"
         self.params = params or []
@@ -233,7 +233,9 @@ class ColumnFacet(Facet):
                 )
                 where {col} is not null
                 group by {col} order by count desc, value limit {limit}
-            """.format(col=escape_sqlite(column), sql=self.sql, limit=facet_size + 1)
+            """.format(
+                col=escape_sqlite(column), sql=self.sql, limit=facet_size + 1
+            )
             try:
                 facet_rows_results = await self.ds.execute(
                     self.database,
@@ -480,7 +482,9 @@ class DateFacet(Facet):
                 select date({column}) from (
                     select * from ({sql}) limit 100
                 ) where {column} glob "????-??-*"
-            """.format(column=escape_sqlite(column), sql=self.sql)
+            """.format(
+                column=escape_sqlite(column), sql=self.sql
+            )
             try:
                 results = await self.ds.execute(
                     self.database,
@@ -526,7 +530,9 @@ class DateFacet(Facet):
                 )
                 where date({col}) is not null
                 group by date({col}) order by count desc, value limit {limit}
-            """.format(col=escape_sqlite(column), sql=self.sql, limit=facet_size + 1)
+            """.format(
+                col=escape_sqlite(column), sql=self.sql, limit=facet_size + 1
+            )
             try:
                 facet_rows_results = await self.ds.execute(
                     self.database,

datasette/filters.py

@@ -1,8 +1,8 @@
 from datasette import hookimpl
-from datasette.resources import DatabaseResource
 from datasette.views.base import DatasetteError
 from datasette.utils.asgi import BadRequest
 import json
+import numbers
 from .utils import detect_json1, escape_sqlite, path_with_removed_args
 
 
@@ -13,10 +13,11 @@ def where_filters(request, database, datasette):
         where_clauses = []
         extra_wheres_for_ui = []
         if "_where" in request.args:
-            if not await datasette.allowed(
-                action="execute-sql",
-                resource=DatabaseResource(database=database),
-                actor=request.actor,
+            if not await datasette.permission_allowed(
+                request.actor,
+                "execute-sql",
+                resource=database,
+                default=True,
             ):
                 raise DatasetteError("_where= is not allowed", status=403)
             else:

datasette/fixtures.py

@@ -1,415 +0,0 @@
-from datasette.utils.sqlite import sqlite3
-from datasette.utils import documented
-import itertools
-import random
-import string
-
-__all__ = [
-    "EXTRA_DATABASE_SQL",
-    "TABLES",
-    "TABLE_PARAMETERIZED_SQL",
-    "generate_compound_rows",
-    "generate_sortable_rows",
-    "populate_extra_database",
-    "populate_fixture_database",
-    "write_extra_database",
-    "write_fixture_database",
-]
-
-
-def generate_compound_rows(num):
-    """Generate rows for the compound_three_primary_keys fixture table."""
-    for a, b, c in itertools.islice(
-        itertools.product(string.ascii_lowercase, repeat=3), num
-    ):
-        yield a, b, c, f"{a}-{b}-{c}"
-
-
-def generate_sortable_rows(num):
-    """Generate rows for the sortable fixture table."""
-    rand = random.Random(42)
-    for a, b in itertools.islice(
-        itertools.product(string.ascii_lowercase, repeat=2), num
-    ):
-        yield {
-            "pk1": a,
-            "pk2": b,
-            "content": f"{a}-{b}",
-            "sortable": rand.randint(-100, 100),
-            "sortable_with_nulls": rand.choice([None, rand.random(), rand.random()]),
-            "sortable_with_nulls_2": rand.choice([None, rand.random(), rand.random()]),
-            "text": rand.choice(["$null", "$blah"]),
-        }
-
-
-TABLES = (
-    """
-CREATE TABLE simple_primary_key (
-  id integer primary key,
-  content text
-);
-
-CREATE TABLE primary_key_multiple_columns (
-  id varchar(30) primary key,
-  content text,
-  content2 text
-);
-
-CREATE TABLE primary_key_multiple_columns_explicit_label (
-  id varchar(30) primary key,
-  content text,
-  content2 text
-);
-
-CREATE TABLE compound_primary_key (
-  pk1 varchar(30),
-  pk2 varchar(30),
-  content text,
-  PRIMARY KEY (pk1, pk2)
-);
-
-INSERT INTO compound_primary_key VALUES ('a', 'b', 'c');
-INSERT INTO compound_primary_key VALUES ('a/b', '.c-d', 'c');
-INSERT INTO compound_primary_key VALUES ('d', 'e', 'RENDER_CELL_DEMO');
-
-CREATE TABLE compound_three_primary_keys (
-  pk1 varchar(30),
-  pk2 varchar(30),
-  pk3 varchar(30),
-  content text,
-  PRIMARY KEY (pk1, pk2, pk3)
-);
-CREATE INDEX idx_compound_three_primary_keys_content ON compound_three_primary_keys(content);
-
-CREATE TABLE foreign_key_references (
-  pk varchar(30) primary key,
-  foreign_key_with_label integer,
-  foreign_key_with_blank_label integer,
-  foreign_key_with_no_label varchar(30),
-  foreign_key_compound_pk1 varchar(30),
-  foreign_key_compound_pk2 varchar(30),
-  FOREIGN KEY (foreign_key_with_label) REFERENCES simple_primary_key(id),
-  FOREIGN KEY (foreign_key_with_blank_label) REFERENCES simple_primary_key(id),
-  FOREIGN KEY (foreign_key_with_no_label) REFERENCES primary_key_multiple_columns(id)
-  FOREIGN KEY (foreign_key_compound_pk1, foreign_key_compound_pk2) REFERENCES compound_primary_key(pk1, pk2)
-);
-
-CREATE TABLE sortable (
-  pk1 varchar(30),
-  pk2 varchar(30),
-  content text,
-  sortable integer,
-  sortable_with_nulls real,
-  sortable_with_nulls_2 real,
-  text text,
-  PRIMARY KEY (pk1, pk2)
-);
-
-CREATE TABLE no_primary_key (
-  content text,
-  a text,
-  b text,
-  c text
-);
-
-CREATE TABLE [123_starts_with_digits] (
-  content text
-);
-
-CREATE VIEW paginated_view AS
-    SELECT
-        content,
-        '- ' || content || ' -' AS content_extra
-    FROM no_primary_key;
-
-CREATE TABLE "Table With Space In Name" (
-  pk varchar(30) primary key,
-  content text
-);
-
-CREATE TABLE "table/with/slashes.csv" (
-  pk varchar(30) primary key,
-  content text
-);
-
-CREATE TABLE "complex_foreign_keys" (
-  pk varchar(30) primary key,
-  f1 integer,
-  f2 integer,
-  f3 integer,
-  FOREIGN KEY ("f1") REFERENCES [simple_primary_key](id),
-  FOREIGN KEY ("f2") REFERENCES [simple_primary_key](id),
-  FOREIGN KEY ("f3") REFERENCES [simple_primary_key](id)
-);
-
-CREATE TABLE "custom_foreign_key_label" (
-  pk varchar(30) primary key,
-  foreign_key_with_custom_label text,
-  FOREIGN KEY ("foreign_key_with_custom_label") REFERENCES [primary_key_multiple_columns_explicit_label](id)
-);
-
-CREATE TABLE tags (
-    tag TEXT PRIMARY KEY
-);
-
-CREATE TABLE searchable (
-  pk integer primary key,
-  text1 text,
-  text2 text,
-  [name with . and spaces] text
-);
-
-CREATE TABLE searchable_tags (
-    searchable_id integer,
-    tag text,
-    PRIMARY KEY (searchable_id, tag),
-    FOREIGN KEY (searchable_id) REFERENCES searchable(pk),
-    FOREIGN KEY (tag) REFERENCES tags(tag)
-);
-
-INSERT INTO searchable VALUES (1, 'barry cat', 'terry dog', 'panther');
-INSERT INTO searchable VALUES (2, 'terry dog', 'sara weasel', 'puma');
-
-INSERT INTO tags VALUES ("canine");
-INSERT INTO tags VALUES ("feline");
-
-INSERT INTO searchable_tags (searchable_id, tag) VALUES
-    (1, "feline"),
-    (2, "canine")
-;
-
-CREATE VIRTUAL TABLE "searchable_fts"
-    USING FTS5 (text1, text2, [name with . and spaces], content="searchable", content_rowid="pk");
-INSERT INTO "searchable_fts" (searchable_fts) VALUES ('rebuild');
-
-CREATE TABLE [select] (
-  [group] text,
-  [having] text,
-  [and] text,
-  [json] text
-);
-INSERT INTO [select] VALUES ('group', 'having', 'and',
-    '{"href": "http://example.com/", "label":"Example"}'
-);
-
-CREATE TABLE infinity (
-    value REAL
-);
-INSERT INTO infinity VALUES
-    (1e999),
-    (-1e999),
-    (1.5)
-;
-
-CREATE TABLE facet_cities (
-    id integer primary key,
-    name text
-);
-INSERT INTO facet_cities (id, name) VALUES
-    (1, 'San Francisco'),
-    (2, 'Los Angeles'),
-    (3, 'Detroit'),
-    (4, 'Memnonia')
-;
-
-CREATE TABLE facetable (
-    pk integer primary key,
-    created text,
-    planet_int integer,
-    on_earth integer,
-    state text,
-    _city_id integer,
-    _neighborhood text,
-    tags text,
-    complex_array text,
-    distinct_some_null,
-    n text,
-    FOREIGN KEY ("_city_id") REFERENCES [facet_cities](id)
-);
-INSERT INTO facetable
-    (created, planet_int, on_earth, state, _city_id, _neighborhood, tags, complex_array, distinct_some_null, n)
-VALUES
-    ("2019-01-14 08:00:00", 1, 1, 'CA', 1, 'Mission', '["tag1", "tag2"]', '[{"foo": "bar"}]', 'one', 'n1'),
-    ("2019-01-14 08:00:00", 1, 1, 'CA', 1, 'Dogpatch', '["tag1", "tag3"]', '[]', 'two', 'n2'),
-    ("2019-01-14 08:00:00", 1, 1, 'CA', 1, 'SOMA', '[]', '[]', null, null),
-    ("2019-01-14 08:00:00", 1, 1, 'CA', 1, 'Tenderloin', '[]', '[]', null, null),
-    ("2019-01-15 08:00:00", 1, 1, 'CA', 1, 'Bernal Heights', '[]', '[]', null, null),
-    ("2019-01-15 08:00:00", 1, 1, 'CA', 1, 'Hayes Valley', '[]', '[]', null, null),
-    ("2019-01-15 08:00:00", 1, 1, 'CA', 2, 'Hollywood', '[]', '[]', null, null),
-    ("2019-01-15 08:00:00", 1, 1, 'CA', 2, 'Downtown', '[]', '[]', null, null),
-    ("2019-01-16 08:00:00", 1, 1, 'CA', 2, 'Los Feliz', '[]', '[]', null, null),
-    ("2019-01-16 08:00:00", 1, 1, 'CA', 2, 'Koreatown', '[]', '[]', null, null),
-    ("2019-01-16 08:00:00", 1, 1, 'MI', 3, 'Downtown', '[]', '[]', null, null),
-    ("2019-01-17 08:00:00", 1, 1, 'MI', 3, 'Greektown', '[]', '[]', null, null),
-    ("2019-01-17 08:00:00", 1, 1, 'MI', 3, 'Corktown', '[]', '[]', null, null),
-    ("2019-01-17 08:00:00", 1, 1, 'MI', 3, 'Mexicantown', '[]', '[]', null, null),
-    ("2019-01-17 08:00:00", 2, 0, 'MC', 4, 'Arcadia Planitia', '[]', '[]', null, null)
-;
-
-CREATE TABLE binary_data (
-    data BLOB
-);
-
--- Many 2 Many demo: roadside attractions!
-
-CREATE TABLE roadside_attractions (
-    pk integer primary key,
-    name text,
-    address text,
-    url text,
-    latitude real,
-    longitude real
-);
-INSERT INTO roadside_attractions VALUES (
-    1, "The Mystery Spot", "465 Mystery Spot Road, Santa Cruz, CA 95065", "https://www.mysteryspot.com/",
-    37.0167, -122.0024
-);
-INSERT INTO roadside_attractions VALUES (
-    2, "Winchester Mystery House", "525 South Winchester Boulevard, San Jose, CA 95128", "https://winchestermysteryhouse.com/",
-    37.3184, -121.9511
-);
-INSERT INTO roadside_attractions VALUES (
-    3, "Burlingame Museum of PEZ Memorabilia", "214 California Drive, Burlingame, CA 94010", null,
-    37.5793, -122.3442
-);
-INSERT INTO roadside_attractions VALUES (
-    4, "Bigfoot Discovery Museum", "5497 Highway 9, Felton, CA 95018", "https://www.bigfootdiscoveryproject.com/",
-    37.0414, -122.0725
-);
-
-CREATE TABLE attraction_characteristic (
-    pk integer primary key,
-    name text
-);
-INSERT INTO attraction_characteristic VALUES (
-    1, "Museum"
-);
-INSERT INTO attraction_characteristic VALUES (
-    2, "Paranormal"
-);
-
-CREATE TABLE roadside_attraction_characteristics (
-    attraction_id INTEGER REFERENCES roadside_attractions(pk),
-    characteristic_id INTEGER REFERENCES attraction_characteristic(pk)
-);
-INSERT INTO roadside_attraction_characteristics VALUES (
-    1, 2
-);
-INSERT INTO roadside_attraction_characteristics VALUES (
-    2, 2
-);
-INSERT INTO roadside_attraction_characteristics VALUES (
-    4, 2
-);
-INSERT INTO roadside_attraction_characteristics VALUES (
-    3, 1
-);
-INSERT INTO roadside_attraction_characteristics VALUES (
-    4, 1
-);
-
-INSERT INTO simple_primary_key VALUES (1, 'hello');
-INSERT INTO simple_primary_key VALUES (2, 'world');
-INSERT INTO simple_primary_key VALUES (3, '');
-INSERT INTO simple_primary_key VALUES (4, 'RENDER_CELL_DEMO');
-INSERT INTO simple_primary_key VALUES (5, 'RENDER_CELL_ASYNC');
-
-INSERT INTO primary_key_multiple_columns VALUES (1, 'hey', 'world');
-INSERT INTO primary_key_multiple_columns_explicit_label VALUES (1, 'hey', 'world2');
-
-INSERT INTO foreign_key_references VALUES (1, 1, 3, 1, 'a', 'b');
-INSERT INTO foreign_key_references VALUES (2, null, null, null, null, null);
-
-INSERT INTO complex_foreign_keys VALUES (1, 1, 2, 1);
-INSERT INTO custom_foreign_key_label VALUES (1, 1);
-
-INSERT INTO [table/with/slashes.csv] VALUES (3, 'hey');
-
-CREATE VIEW simple_view AS
-    SELECT content, upper(content) AS upper_content FROM simple_primary_key;
-
-CREATE VIEW searchable_view AS
-    SELECT * from searchable;
-
-CREATE VIEW searchable_view_configured_by_metadata AS
-    SELECT * from searchable;
-
-"""
-    + "\n".join(
-        [
-            'INSERT INTO no_primary_key VALUES ({i}, "a{i}", "b{i}", "c{i}");'.format(
-                i=i + 1
-            )
-            for i in range(201)
-        ]
-    )
-    + '\nINSERT INTO no_primary_key VALUES ("RENDER_CELL_DEMO", "a202", "b202", "c202");\n'
-    + "\n".join(
-        [
-            'INSERT INTO compound_three_primary_keys VALUES ("{a}", "{b}", "{c}", "{content}");'.format(
-                a=a, b=b, c=c, content=content
-            )
-            for a, b, c, content in generate_compound_rows(1001)
-        ]
-    )
-    + "\n".join(["""INSERT INTO sortable VALUES (
-        "{pk1}", "{pk2}", "{content}", {sortable},
-        {sortable_with_nulls}, {sortable_with_nulls_2}, "{text}");
-    """.format(**row).replace("None", "null") for row in generate_sortable_rows(201)])
-)
-
-TABLE_PARAMETERIZED_SQL = [
-    ("insert into binary_data (data) values (?);", [b"\x15\x1c\x02\xc7\xad\x05\xfe"]),
-    ("insert into binary_data (data) values (?);", [b"\x15\x1c\x03\xc7\xad\x05\xfe"]),
-    ("insert into binary_data (data) values (null);", []),
-]
-
-EXTRA_DATABASE_SQL = """
-CREATE TABLE searchable (
-  pk integer primary key,
-  text1 text,
-  text2 text
-);
-
-CREATE VIEW searchable_view AS SELECT * FROM searchable;
-
-INSERT INTO searchable VALUES (1, 'barry cat', 'terry dog');
-INSERT INTO searchable VALUES (2, 'terry dog', 'sara weasel');
-
-CREATE VIRTUAL TABLE "searchable_fts"
-    USING FTS3 (text1, text2, content="searchable");
-INSERT INTO "searchable_fts" (rowid, text1, text2)
-    SELECT rowid, text1, text2 FROM searchable;
-"""
-
-
-@documented(label="datasette_fixtures_populate_fixture_database")
-def populate_fixture_database(conn):
-    """Populate a SQLite connection with Datasette's test fixture tables."""
-    conn.executescript(TABLES)
-    for sql, params in TABLE_PARAMETERIZED_SQL:
-        with conn:
-            conn.execute(sql, params)
-
-
-def populate_extra_database(conn):
-    """Populate a SQLite connection with the extra database used in tests."""
-    conn.executescript(EXTRA_DATABASE_SQL)
-
-
-def write_fixture_database(db_filename):
-    """Write Datasette's test fixture tables to a SQLite database file."""
-    conn = sqlite3.connect(db_filename)
-    try:
-        populate_fixture_database(conn)
-    finally:
-        conn.close()
-
-
-def write_extra_database(db_filename):
-    """Write the extra test database tables to a SQLite database file."""
-    conn = sqlite3.connect(db_filename)
-    try:
-        populate_extra_database(conn)
-    finally:
-        conn.close()

datasette/hookspecs.py

@@ -55,17 +55,7 @@ def publish_subcommand(publish):
 
 
 @hookspec
-def render_cell(
-    row,
-    value,
-    column,
-    table,
-    pks,
-    database,
-    datasette,
-    request,
-    column_type,
-):
+def render_cell(row, value, column, table, database, datasette, request):
     """Customize rendering of HTML table cell values"""
 
 
@@ -80,13 +70,8 @@ def register_facet_classes():
 
 
 @hookspec
-def register_actions(datasette):
-    """Register actions: returns a list of datasette.permission.Action objects"""
-
-
-@hookspec
-def register_column_types(datasette):
-    """Return a list of ColumnType subclasses"""
+def register_permissions(datasette):
+    """Register permissions: returns a list of datasette.permission.Permission named tuples"""
 
 
 @hookspec
@@ -125,18 +110,28 @@ def filters_from_request(request, database, table, datasette):
     ) based on the request"""
 
 
+@hookspec
+def permission_allowed(datasette, actor, action, resource):
+    """Check if actor is allowed to perform this action - return True, False or None"""
+
+
 @hookspec
 def permission_resources_sql(datasette, actor, action):
     """Return SQL query fragments for permission checks on resources.
 
-    Returns None, a PermissionSQL object, or a list of PermissionSQL objects.
-    Each PermissionSQL contains SQL that should return rows with columns:
+    Returns None, a PluginSQL object, or a list of PluginSQL objects.
+    Each PluginSQL contains SQL that should return rows with columns:
     parent (str|None), child (str|None), allow (int), reason (str).
 
     Used to efficiently check permissions across multiple resources at once.
     """
 
 
+@hookspec
+def canned_queries(datasette, database, actor):
+    """Return a dictionary of canned query definitions or an awaitable function that returns them"""
+
+
 @hookspec
 def register_magic_parameters(datasette):
     """Return a list of (name, function) magic parameter functions"""
@@ -152,11 +147,6 @@ def menu_links(datasette, actor, request):
     """Links for the navigation menu"""
 
 
-@hookspec
-def jump_items_sql(datasette, actor, request):
-    """SQL fragments for extra items in the jump menu"""
-
-
 @hookspec
 def row_actions(datasette, actor, request, database, table, row):
     """Links for the row actions menu"""
@@ -174,7 +164,7 @@ def view_actions(datasette, actor, database, view, request):
 
 @hookspec
 def query_actions(datasette, actor, database, query_name, request, sql, params):
-    """Links for the query and stored query actions menu"""
+    """Links for the query and canned query actions menu"""
 
 
 @hookspec
@@ -187,6 +177,11 @@ def homepage_actions(datasette, actor, request):
     """Links for the homepage actions menu"""
 
 
+@hookspec
+def skip_csrf(datasette, scope):
+    """Mechanism for skipping CSRF checks for certain requests"""
+
+
 @hookspec
 def handle_exception(datasette, request, exception):
     """Handle an uncaught exception. Can return a Response or None."""
@@ -228,38 +223,5 @@ def top_query(datasette, request, database, sql):
 
 
 @hookspec
-def top_stored_query(datasette, request, database, query_name):
-    """HTML to include at the top of the stored query page"""
-
-
-@hookspec
-def register_token_handler(datasette):
-    """Return a TokenHandler instance for token creation and verification"""
-
-
-@hookspec
-def write_wrapper(datasette, database, request, transaction):
-    """Called when a write function is about to execute.
-
-    Return a generator function that accepts a ``conn`` argument and
-    optionally a ``track_event`` argument.  The generator should
-    ``yield`` exactly once: code before the ``yield`` runs before
-    the write, code after the ``yield`` runs after the write
-    completes. The result of the write is sent back through the
-    ``yield``, so you can capture it with ``result = yield``.
-
-    If your generator accepts ``track_event``, you can call
-    ``track_event(event)`` to queue an event that will be dispatched
-    via ``datasette.track_event()`` after the write commits
-    successfully.  Events are discarded if the write raises an
-    exception.
-
-    If the write raises an exception, it is thrown into the generator
-    so you can handle it with a try/except around the ``yield``.
-
-    ``request`` may be ``None`` for writes not originating from an
-    HTTP request.  ``transaction`` is ``True`` if the write will
-    be wrapped in a transaction.
-
-    Return ``None`` to skip wrapping.
-    """
+def top_canned_query(datasette, request, database, query_name):
+    """HTML to include at the top of the canned query page"""

datasette/inspect.py

@@ -10,6 +10,7 @@ from .utils import (
     sqlite3,
 )
 
+
 HASH_BLOCK_SIZE = 1024 * 1024
 
 
@@ -69,11 +70,16 @@ def inspect_tables(conn, database_metadata):
         tables[table]["foreign_keys"] = info
 
     # Mark tables 'hidden' if they relate to FTS virtual tables
-    hidden_tables = [r["name"] for r in conn.execute("""
+    hidden_tables = [
+        r["name"]
+        for r in conn.execute(
+            """
                 select name from sqlite_master
                 where rootpage = 0
                 and sql like '%VIRTUAL TABLE%USING FTS%'
-            """)]
+            """
+        )
+    ]
 
     if detect_spatialite(conn):
         # Also hide Spatialite internal tables
@@ -88,11 +94,14 @@ def inspect_tables(conn, database_metadata):
             "views_geometry_columns",
             "virts_geometry_columns",
         ] + [
-            r["name"] for r in conn.execute("""
+            r["name"]
+            for r in conn.execute(
+                """
                     select name from sqlite_master
                     where name like "idx_%"
                     and type = "table"
-                """)
+                """
+            )
         ]
 
     for t in tables.keys():

datasette/jump.py

@@ -1,68 +0,0 @@
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-from typing import Any
-
-
-@dataclass
-class JumpSQL:
-    sql: str
-    params: dict[str, Any] | None = None
-    database: str | None = None
-
-    @classmethod
-    def menu_item(
-        cls,
-        *,
-        label: str,
-        url: str,
-        description: str = "Menu item",
-        search_text: str | None = None,
-        display_name: str | None = None,
-        item_type: str = "menu",
-    ) -> "JumpSQL":
-        if search_text is None:
-            search_text = " ".join(
-                text for text in (label, display_name, description) if text is not None
-            )
-        return cls(
-            sql="""
-            SELECT
-                :type AS type,
-                :label AS label,
-                :description AS description,
-                :url AS url,
-                :search_text AS search_text,
-                :display_name AS display_name
-            """,
-            params={
-                "type": item_type,
-                "label": label,
-                "description": description,
-                "url": url,
-                "search_text": search_text,
-                "display_name": display_name,
-            },
-        )
-
-
-_PARAM_RE = re.compile(r"(?<!:):([A-Za-z_][A-Za-z0-9_]*)")
-
-
-def namespace_sql_params(sql: str, params: dict[str, Any], prefix: str):
-    """Rename named SQL parameters so UNION query parameters cannot collide."""
-    if not params:
-        return sql, {}
-
-    renamed = {key: f"{prefix}_{key}" for key in params}
-
-    def replace(match):
-        key = match.group(1)
-        if key not in renamed:
-            return match.group(0)
-        return f":{renamed[key]}"
-
-    return _PARAM_RE.sub(replace, sql), {
-        renamed[key]: value for key, value in params.items()
-    }

datasette/permissions.py

@@ -1,215 +1,12 @@
-from abc import ABC, abstractmethod
 from dataclasses import dataclass
-from typing import Any, NamedTuple
-import contextvars
-
-# Context variable to track when permission checks should be skipped
-_skip_permission_checks = contextvars.ContextVar(
-    "skip_permission_checks", default=False
-)
+from typing import Optional
 
 
-class SkipPermissions:
-    """Context manager to temporarily skip permission checks.
-
-    This is not a stable API and may change in future releases.
-
-    Usage:
-        with SkipPermissions():
-            # Permission checks are skipped within this block
-            response = await datasette.client.get("/protected")
-    """
-
-    def __enter__(self):
-        self.token = _skip_permission_checks.set(True)
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        _skip_permission_checks.reset(self.token)
-        return False
-
-
-class Resource(ABC):
-    """
-    Base class for all resource types.
-
-    Each subclass represents a type of resource (e.g., TableResource, DatabaseResource).
-    The class itself carries metadata about the resource type.
-    Instances represent specific resources.
-    """
-
-    # Class-level metadata (subclasses must define these)
-    name: str = None  # e.g., "table", "database", "model"
-    parent_class: type["Resource"] | None = None  # e.g., DatabaseResource for tables
-
-    # Instance-level optional extra attributes
-    reasons: list[str] | None = None
-    include_reasons: bool | None = None
-
-    def __init__(self, parent: str | None = None, child: str | None = None):
-        """
-        Create a resource instance.
-
-        Args:
-            parent: The parent identifier (meaning depends on resource type)
-            child: The child identifier (meaning depends on resource type)
-        """
-        self.parent = parent
-        self.child = child
-        self._private = None  # Sentinel to track if private was set
-
-    def __str__(self) -> str:
-        return "/".join(
-            str(part) for part in (self.parent, self.child) if part is not None
-        )
-
-    def __repr__(self) -> str:
-        return "{}(parent={!r}, child={!r})".format(
-            self.__class__.__name__, self.parent, self.child
-        )
-
-    @property
-    def private(self) -> bool:
-        """
-        Whether this resource is private (accessible to actor but not anonymous).
-
-        This property is only available on Resource objects returned from
-        allowed_resources() when include_is_private=True is used.
-
-        Raises:
-            AttributeError: If accessed without calling include_is_private=True
-        """
-        if self._private is None:
-            raise AttributeError(
-                "The 'private' attribute is only available when using "
-                "allowed_resources(..., include_is_private=True)"
-            )
-        return self._private
-
-    @private.setter
-    def private(self, value: bool):
-        self._private = value
-
-    @classmethod
-    def __init_subclass__(cls):
-        """
-        Validate resource hierarchy doesn't exceed 2 levels.
-
-        Raises:
-            ValueError: If this resource would create a 3-level hierarchy
-        """
-        super().__init_subclass__()
-
-        if cls.parent_class is None:
-            return  # Top of hierarchy, nothing to validate
-
-        # Check if our parent has a parent - that would create 3 levels
-        if cls.parent_class.parent_class is not None:
-            # We have a parent, and that parent has a parent
-            # This creates a 3-level hierarchy, which is not allowed
-            raise ValueError(
-                f"Resource {cls.__name__} creates a 3-level hierarchy: "
-                f"{cls.parent_class.parent_class.__name__} -> {cls.parent_class.__name__} -> {cls.__name__}. "
-                f"Maximum 2 levels allowed (parent -> child)."
-            )
-
-    @classmethod
-    @abstractmethod
-    async def resources_sql(cls, datasette, actor=None) -> str:
-        """
-        Return SQL query that returns all resources of this type.
-
-        Must return two columns: parent, child
-        """
-        pass
-
-
-class AllowedResource(NamedTuple):
-    """A resource with the reason it was allowed (for debugging)."""
-
-    resource: Resource
-    reason: str
-
-
-@dataclass(frozen=True, kw_only=True)
-class Action:
-    name: str
-    description: str | None
-    abbr: str | None = None
-    resource_class: type[Resource] | None = None
-    also_requires: str | None = None  # Optional action name that must also be allowed
-
-    @property
-    def takes_parent(self) -> bool:
-        """
-        Whether this action requires a parent identifier when instantiating its resource.
-
-        Returns False for global-only actions (no resource_class).
-        Returns True for all actions with a resource_class (all resources require a parent identifier).
-        """
-        return self.resource_class is not None
-
-    @property
-    def takes_child(self) -> bool:
-        """
-        Whether this action requires a child identifier when instantiating its resource.
-
-        Returns False for global actions (no resource_class).
-        Returns False for parent-level resources (DatabaseResource - parent_class is None).
-        Returns True for child-level resources (TableResource, QueryResource - have a parent_class).
-        """
-        if self.resource_class is None:
-            return False
-        return self.resource_class.parent_class is not None
-
-
-_reason_id = 1
-
-
-@dataclass
-class PermissionSQL:
-    """
-    A plugin contributes SQL that yields:
-      parent TEXT NULL,
-      child  TEXT NULL,
-      allow  INTEGER,    -- 1 allow, 0 deny
-      reason TEXT
-
-    For restriction-only plugins, sql can be None and only restriction_sql is provided.
-    """
-
-    sql: str | None = (
-        None  # SQL that SELECTs the 4 columns above (can be None for restriction-only)
-    )
-    params: dict[str, Any] | None = (
-        None  # bound params for the SQL (values only; no ':' prefix)
-    )
-    source: str | None = None  # System will set this to the plugin name
-    restriction_sql: str | None = (
-        None  # Optional SQL that returns (parent, child) for restriction filtering
-    )
-
-    @classmethod
-    def allow(cls, reason: str, _allow: bool = True) -> "PermissionSQL":
-        global _reason_id
-        i = _reason_id
-        _reason_id += 1
-        return cls(
-            sql=f"SELECT NULL AS parent, NULL AS child, {1 if _allow else 0} AS allow, :reason_{i} AS reason",
-            params={f"reason_{i}": reason},
-        )
-
-    @classmethod
-    def deny(cls, reason: str) -> "PermissionSQL":
-        return cls.allow(reason=reason, _allow=False)
-
-
-# This is obsolete, replaced by Action and ResourceType
 @dataclass
 class Permission:
     name: str
-    abbr: str | None
-    description: str | None
+    abbr: Optional[str]
+    description: Optional[str]
     takes_database: bool
     takes_resource: bool
     default: bool

datasette/plugins.py

@@ -23,14 +23,9 @@ DEFAULT_PLUGINS = (
     "datasette.sql_functions",
     "datasette.actor_auth_cookie",
     "datasette.default_permissions",
-    "datasette.default_permissions.tokens",
-    "datasette.default_actions",
-    "datasette.default_column_types",
     "datasette.default_magic_parameters",
     "datasette.blob_renderer",
-    "datasette.default_debug_menu",
-    "datasette.default_jump_items",
-    "datasette.default_database_actions",
+    "datasette.default_menu_links",
     "datasette.handle_exception",
     "datasette.forbidden",
     "datasette.events",
@@ -54,7 +49,7 @@ def after(outcome, hook_name, hook_impls, kwargs):
     results = outcome.get_result()
     if not isinstance(results, list):
         results = [results]
-    print("Results:", file=sys.stderr)
+    print(f"Results:", file=sys.stderr)
     pprint(results, width=40, indent=4, stream=sys.stderr)
 
 
@@ -98,24 +93,21 @@ def get_plugins():
     for plugin in pm.get_plugins():
         static_path = None
         templates_path = None
-        plugin_name = (
-            plugin.__name__
-            if hasattr(plugin, "__name__")
-            else plugin.__class__.__name__
-        )
-        if plugin_name not in DEFAULT_PLUGINS:
+        if plugin.__name__ not in DEFAULT_PLUGINS:
             try:
-                if (importlib_resources.files(plugin_name) / "static").is_dir():
-                    static_path = str(importlib_resources.files(plugin_name) / "static")
-                if (importlib_resources.files(plugin_name) / "templates").is_dir():
+                if (importlib_resources.files(plugin.__name__) / "static").is_dir():
+                    static_path = str(
+                        importlib_resources.files(plugin.__name__) / "static"
+                    )
+                if (importlib_resources.files(plugin.__name__) / "templates").is_dir():
                     templates_path = str(
-                        importlib_resources.files(plugin_name) / "templates"
+                        importlib_resources.files(plugin.__name__) / "templates"
                     )
             except (TypeError, ModuleNotFoundError):
                 # Caused by --plugins_dir= plugins
                 pass
         plugin_info = {
-            "name": plugin_name,
+            "name": plugin.__name__,
             "static_path": static_path,
             "templates_path": templates_path,
             "hooks": [h.name for h in pm.get_hookcallers(plugin)],

datasette/publish/cloudrun.py

@@ -23,9 +23,7 @@ def publish_subcommand(publish):
         help="Application name to use when building",
     )
     @click.option(
-        "--service",
-        default="",
-        help="Cloud Run service to deploy (or over-write)",
+        "--service", default="", help="Cloud Run service to deploy (or over-write)"
     )
     @click.option("--spatialite", is_flag=True, help="Enable SpatialLite extension")
     @click.option(
@@ -303,7 +301,6 @@ def get_existing_services():
             "url": service["status"]["address"]["url"],
         }
         for service in services
-        if "url" in service["status"]
     ]
 
 

datasette/renderer.py

@@ -20,7 +20,7 @@ def convert_specific_columns_to_json(rows, columns, json_cols):
             if column in json_cols:
                 try:
                     value = json.loads(value)
-                except (TypeError, ValueError):
+                except (TypeError, ValueError) as e:
                     pass
             new_row.append(value)
         new_rows.append(new_row)

datasette/resources.py

@@ -1,58 +0,0 @@
-"""Core resource types for Datasette's permission system."""
-
-from datasette.permissions import Resource
-
-
-class DatabaseResource(Resource):
-    """A database in Datasette."""
-
-    name = "database"
-    parent_class = None  # Top of the resource hierarchy
-
-    def __init__(self, database: str):
-        super().__init__(parent=database, child=None)
-
-    @classmethod
-    async def resources_sql(cls, datasette, actor=None) -> str:
-        return """
-            SELECT database_name AS parent, NULL AS child
-            FROM catalog_databases
-        """
-
-
-class TableResource(Resource):
-    """A table in a database."""
-
-    name = "table"
-    parent_class = DatabaseResource
-
-    def __init__(self, database: str, table: str):
-        super().__init__(parent=database, child=table)
-
-    @classmethod
-    async def resources_sql(cls, datasette, actor=None) -> str:
-        return """
-            SELECT database_name AS parent, table_name AS child
-            FROM catalog_tables
-            UNION ALL
-            SELECT database_name AS parent, view_name AS child
-            FROM catalog_views
-        """
-
-
-class QueryResource(Resource):
-    """A stored query in a database."""
-
-    name = "query"
-    parent_class = DatabaseResource
-
-    def __init__(self, database: str, query: str):
-        super().__init__(parent=database, child=query)
-
-    @classmethod
-    async def resources_sql(cls, datasette, actor=None) -> str:
-        return """
-            SELECT q.database_name AS parent, q.name AS child
-            FROM queries q
-            JOIN catalog_databases cd ON cd.database_name = q.database_name
-        """

datasette/static/app.css

@@ -63,14 +63,6 @@ em {
 }
 /* end reset */
 
-/* Modal CSS variables (shared by web components via Shadow DOM) */
-:root {
-    --modal-backdrop-bg: rgba(0, 0, 0, 0.5);
-    --modal-backdrop-blur: blur(4px);
-    --modal-border-radius: 0.75rem;
-    --modal-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
-    --modal-animation-duration: 0.2s;
-}
 
 body {
     margin: 0;
@@ -362,32 +354,6 @@ form.nav-menu-logout {
 .nav-menu-inner a {
     display: block;
 }
-.nav-menu-inner button.button-as-link {
-    display: block;
-    width: 100%;
-    text-align: left;
-    font: inherit;
-}
-.nav-menu-inner .keyboard-shortcut {
-    float: right;
-    box-sizing: border-box;
-    min-width: 1.4em;
-    margin-left: 0.75rem;
-    padding: 0 0.35em;
-    border: 1px solid rgba(255,255,244,0.6);
-    border-radius: 3px;
-    background: rgba(255,255,244,0.12);
-    font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
-    font-size: 0.85em;
-    line-height: 1.35;
-    text-align: center;
-    text-decoration: none;
-}
-@media (max-width: 640px) {
-    .nav-menu-inner .keyboard-shortcut {
-        display: none;
-    }
-}
 
 /* Table/database actions menu */
 .page-action-menu {
@@ -681,14 +647,10 @@ button.core[type=button] {
     border-radius: 3px;
     -webkit-appearance: none;
     padding: 9px 4px;
-    font-size: 16px;
+    font-size: 1em;
     font-family: Helvetica, sans-serif;
 }
 
-#_search {
-    font-size: 16px;
-}
-
 
 
 
@@ -768,474 +730,6 @@ p.zero-results {
 .select-wrapper.small-screen-only {
     display: none;
 }
-
-@keyframes datasette-modal-slide-in {
-    from {
-        opacity: 0;
-        transform: translateY(-20px) scale(0.95);
-    }
-    to {
-        opacity: 1;
-        transform: translateY(0) scale(1);
-    }
-}
-
-@keyframes datasette-modal-fade-in {
-    from { opacity: 0; }
-    to { opacity: 1; }
-}
-
-dialog.mobile-column-actions-dialog {
-    --ink: #0f0f0f;
-    --paper: #f5f3ef;
-    --muted: #6b6b6b;
-    --rule: #e2dfd8;
-    --accent: #1a56db;
-    --card: #ffffff;
-    border: none;
-    border-radius: var(--modal-border-radius, 0.75rem);
-    padding: 0;
-    margin: auto;
-    width: min(420px, calc(100vw - 32px));
-    max-width: 95vw;
-    max-height: min(640px, calc(100vh - 32px));
-    box-shadow: var(--modal-shadow, 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04));
-    animation: datasette-modal-slide-in var(--modal-animation-duration, 0.2s) ease-out;
-    overflow: hidden;
-    font-family: system-ui, -apple-system, sans-serif;
-    background: var(--card);
-}
-
-dialog.mobile-column-actions-dialog[open] {
-    display: flex;
-    flex-direction: column;
-}
-
-dialog.mobile-column-actions-dialog::backdrop {
-    background: var(--modal-backdrop-bg, rgba(0, 0, 0, 0.5));
-    backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-    -webkit-backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-    animation: datasette-modal-fade-in var(--modal-animation-duration, 0.2s) ease-out;
-}
-
-.mobile-column-actions-dialog .modal-header {
-    padding: 20px 24px 16px;
-    border-bottom: 1px solid var(--rule);
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 12px;
-    flex-shrink: 0;
-}
-
-.mobile-column-actions-dialog .modal-title {
-    font-size: 1rem;
-    font-weight: 600;
-    color: var(--ink);
-}
-
-.mobile-column-actions-dialog .modal-meta {
-    font-family: ui-monospace, monospace;
-    font-size: 0.7rem;
-    color: var(--muted);
-    background: var(--paper);
-    padding: 3px 9px;
-    border-radius: 20px;
-}
-
-.mobile-column-actions-dialog .list-wrap {
-    flex: 1 1 auto;
-    min-height: 0;
-    overflow-y: auto;
-    overflow-x: hidden;
-    position: relative;
-    overscroll-behavior: contain;
-    -webkit-overflow-scrolling: touch;
-}
-
-.mobile-column-actions-dialog .list-wrap::before,
-.mobile-column-actions-dialog .list-wrap::after {
-    content: "";
-    position: sticky;
-    display: block;
-    left: 0;
-    right: 0;
-    height: 20px;
-    pointer-events: none;
-    z-index: 5;
-}
-
-.mobile-column-actions-dialog .list-wrap::before {
-    top: 0;
-    background: linear-gradient(to bottom, rgba(255,255,255,0.9), transparent);
-}
-
-.mobile-column-actions-dialog .list-wrap::after {
-    bottom: 0;
-    background: linear-gradient(to top, rgba(255,255,255,0.9), transparent);
-    margin-top: -20px;
-}
-
-.mobile-column-top-actions {
-    padding: 10px 24px 0;
-}
-
-.mobile-column-top-action {
-    display: inline-block;
-    text-decoration: none;
-}
-
-.mobile-column-section {
-    border-bottom: 1px solid var(--rule);
-}
-
-.mobile-column-actions-dialog .col-header {
-    width: 100%;
-    padding: 12px 24px;
-    font: inherit;
-    font-weight: 600;
-    border: 0;
-    background: none;
-    cursor: pointer;
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    text-align: left;
-}
-
-.mobile-column-header-text {
-    display: flex;
-    flex-direction: column;
-    gap: 0.15rem;
-}
-
-.mobile-column-name {
-    color: var(--ink);
-}
-
-.mobile-column-meta {
-    color: var(--muted);
-    font-size: 0.78em;
-    font-family: ui-monospace, monospace;
-    font-weight: normal;
-}
-
-.mobile-column-chevron {
-    color: var(--muted);
-    transition: transform 0.2s ease-out;
-}
-
-.mobile-column-actions-dialog .col-header[aria-expanded="true"] .mobile-column-chevron {
-    transform: rotate(180deg);
-}
-
-.mobile-column-actions-dialog .col-actions[hidden] {
-    display: none;
-}
-
-.mobile-column-actions-dialog .col-actions ul,
-.mobile-column-actions-dialog .col-actions li {
-    margin: 0;
-    padding: 0;
-    list-style-type: none;
-}
-
-.mobile-column-actions-dialog .col-actions a,
-.mobile-column-actions-dialog .col-actions button {
-    display: block;
-    width: 100%;
-    padding: 10px 24px 10px 40px;
-    color: var(--ink);
-    text-align: left;
-    font: inherit;
-    text-decoration: none;
-    background: none;
-    border: 0;
-    border-top: 1px solid #f5f5f5;
-    cursor: pointer;
-}
-
-.mobile-column-actions-dialog .col-actions a:hover,
-.mobile-column-actions-dialog .col-actions button:hover {
-    background: var(--paper);
-}
-
-.mobile-column-actions-dialog .col-actions a:active,
-.mobile-column-actions-dialog .col-actions button:active {
-    background: #eee;
-}
-
-.mobile-column-description,
-.mobile-column-no-actions {
-    margin: 0;
-    padding: 0 24px 12px 24px;
-    color: var(--muted);
-    font-size: 0.85em;
-}
-
-.mobile-column-actions-dialog .modal-footer {
-    padding: 14px 20px;
-    border-top: 1px solid var(--rule);
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    flex-shrink: 0;
-    background: var(--paper);
-}
-
-.mobile-column-actions-dialog .footer-info {
-    flex: 1;
-    font-family: ui-monospace, monospace;
-    font-size: 0.68rem;
-    color: var(--muted);
-}
-
-.mobile-column-actions-dialog .btn {
-    border: none;
-    border-radius: 5px;
-    padding: 9px 20px;
-    font-size: 0.85rem;
-    font-weight: 500;
-    cursor: pointer;
-    touch-action: manipulation;
-    font-family: inherit;
-    transition: background 0.12s;
-}
-
-.mobile-column-actions-dialog .btn-ghost {
-    background: transparent;
-    color: var(--muted);
-    border: 1px solid var(--rule);
-}
-
-.mobile-column-actions-dialog .btn-ghost:hover {
-    background: var(--rule);
-    color: var(--ink);
-}
-
-dialog.set-column-type-dialog {
-    --ink: #0f0f0f;
-    --paper: #f5f3ef;
-    --muted: #6b6b6b;
-    --rule: #e2dfd8;
-    --accent: #1a56db;
-    --card: #ffffff;
-    border: none;
-    border-radius: var(--modal-border-radius, 0.75rem);
-    padding: 0;
-    margin: auto;
-    width: min(520px, calc(100vw - 32px));
-    max-width: 95vw;
-    max-height: min(720px, calc(100vh - 32px));
-    box-shadow: var(--modal-shadow, 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04));
-    animation: datasette-modal-slide-in var(--modal-animation-duration, 0.2s) ease-out;
-    overflow: hidden;
-    font-family: system-ui, -apple-system, sans-serif;
-    background: var(--card);
-}
-
-dialog.set-column-type-dialog[open] {
-    display: flex;
-    flex-direction: column;
-}
-
-dialog.set-column-type-dialog::backdrop {
-    background: var(--modal-backdrop-bg, rgba(0, 0, 0, 0.5));
-    backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-    -webkit-backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-    animation: datasette-modal-fade-in var(--modal-animation-duration, 0.2s) ease-out;
-}
-
-.set-column-type-dialog .modal-header {
-    padding: 20px 24px 12px;
-    border-bottom: 1px solid var(--rule);
-    display: flex;
-    align-items: center;
-    justify-content: space-between;
-    gap: 12px;
-    flex-shrink: 0;
-}
-
-.set-column-type-dialog .modal-title {
-    font-size: 1rem;
-    font-weight: 600;
-    color: var(--ink);
-}
-
-.set-column-type-dialog .modal-meta {
-    font-family: ui-monospace, monospace;
-    font-size: 0.7rem;
-    color: var(--muted);
-    background: var(--paper);
-    padding: 3px 9px;
-    border-radius: 20px;
-}
-
-.set-column-type-status,
-.set-column-type-empty,
-.set-column-type-error {
-    margin: 0;
-    padding: 12px 24px 0;
-}
-
-.set-column-type-status,
-.set-column-type-empty {
-    color: var(--muted);
-    font-size: 0.9rem;
-}
-
-.set-column-type-error {
-    color: #b91c1c;
-    font-size: 0.9rem;
-}
-
-.set-column-type-options {
-    padding: 16px 24px 24px;
-    overflow-y: auto;
-    display: grid;
-    gap: 12px;
-}
-
-.set-column-type-option {
-    display: grid;
-    grid-template-columns: auto 1fr;
-    gap: 12px;
-    align-items: start;
-    padding: 14px 16px;
-    border: 1px solid var(--rule);
-    border-radius: 8px;
-    background: #fcfbf9;
-    cursor: pointer;
-}
-
-.set-column-type-option:focus-within {
-    border-color: var(--accent);
-    box-shadow: 0 0 0 3px rgba(26, 86, 219, 0.12);
-}
-
-.set-column-type-option input {
-    margin-top: 3px;
-}
-
-.set-column-type-option-content {
-    display: grid;
-    gap: 4px;
-}
-
-.set-column-type-option-name {
-    font-family: ui-monospace, monospace;
-    font-size: 0.95rem;
-    color: var(--ink);
-}
-
-.set-column-type-option-description {
-    color: var(--muted);
-    font-size: 0.9rem;
-}
-
-.set-column-type-dialog .modal-footer {
-    padding: 14px 20px;
-    border-top: 1px solid var(--rule);
-    display: flex;
-    align-items: center;
-    gap: 10px;
-    flex-shrink: 0;
-    background: var(--paper);
-}
-
-.set-column-type-dialog .footer-info {
-    flex: 1;
-    font-family: ui-monospace, monospace;
-    font-size: 0.68rem;
-    color: var(--muted);
-}
-
-.set-column-type-dialog .btn {
-    border: none;
-    border-radius: 5px;
-    padding: 9px 20px;
-    font-size: 0.85rem;
-    font-weight: 500;
-    cursor: pointer;
-    touch-action: manipulation;
-    font-family: inherit;
-    transition: background 0.12s;
-}
-
-.set-column-type-dialog .btn-ghost {
-    background: transparent;
-    color: var(--muted);
-    border: 1px solid var(--rule);
-}
-
-.set-column-type-dialog .btn-ghost:hover {
-    background: var(--rule);
-    color: var(--ink);
-}
-
-.set-column-type-dialog .btn-primary {
-    background: var(--accent);
-    color: #fff;
-}
-
-.set-column-type-dialog .btn-primary:hover {
-    background: #1949b8;
-}
-
-.set-column-type-dialog .btn:disabled {
-    opacity: 0.65;
-    cursor: wait;
-}
-
-@media (max-width: 640px) {
-    dialog.mobile-column-actions-dialog {
-        width: 95vw;
-        max-height: 85vh;
-        border-radius: 0.5rem;
-    }
-
-    .mobile-column-actions-dialog .modal-header {
-        padding: 16px 18px 14px;
-    }
-
-    .mobile-column-top-actions {
-        padding-left: 18px;
-        padding-right: 18px;
-    }
-
-    .mobile-column-actions-dialog .col-header {
-        padding-left: 18px;
-        padding-right: 18px;
-    }
-
-    .mobile-column-actions-dialog .col-actions a,
-    .mobile-column-actions-dialog .col-actions button {
-        padding-left: 34px;
-        padding-right: 18px;
-    }
-
-    .mobile-column-description,
-    .mobile-column-no-actions {
-        padding-left: 18px;
-        padding-right: 18px;
-    }
-
-    dialog.set-column-type-dialog {
-        width: 95vw;
-        max-height: 85vh;
-        border-radius: 0.5rem;
-    }
-
-    .set-column-type-dialog .modal-header,
-    .set-column-type-status,
-    .set-column-type-empty,
-    .set-column-type-error,
-    .set-column-type-options {
-        padding-left: 18px;
-        padding-right: 18px;
-    }
-}
-
 @media only screen and (max-width: 576px) {
 
     .small-screen-only {
@@ -1297,43 +791,6 @@ dialog.set-column-type-dialog::backdrop {
     .filters input.filter-value {
         width: 140px;
     }
-    button.choose-columns-mobile,
-    button.column-actions-mobile {
-        display: inline-flex;
-        align-items: center;
-        justify-content: center;
-        padding: 0.5rem 1rem;
-        margin-bottom: 1em;
-        font-size: 0.9rem;
-        line-height: 1.2;
-        font-family: inherit;
-        background: white;
-        border: 1px solid #ccc;
-        border-radius: 5px;
-        cursor: pointer;
-        vertical-align: top;
-        box-sizing: border-box;
-        min-height: 2.5rem;
-    }
-
-    button.column-actions-mobile {
-        gap: 0.55rem;
-    }
-
-    button.column-actions-mobile svg {
-        display: block;
-        width: 16px;
-        height: 16px;
-        flex-shrink: 0;
-    }
-
-    button.column-actions-mobile span {
-        line-height: 1.2;
-    }
-
-    button.choose-columns-mobile {
-        margin-right: 0.5rem;
-    }
 }
 
 svg.dropdown-menu-icon {
@@ -1409,15 +866,11 @@ svg.dropdown-menu-icon {
     border-bottom: 5px solid #666;
 }
 
-.stored-query-edit-sql {
+.canned-query-edit-sql {
     padding-left: 0.5em;
     position: relative;
     top: 1px;
 }
-.save-query {
-    display: inline-block;
-    margin-left: 0.45em;
-}
 
 .blob-download {
     display: block;

datasette/static/column-chooser.js

@@ -1,699 +0,0 @@
-class ColumnChooser extends HTMLElement {
-  constructor() {
-    super();
-    this.attachShadow({ mode: "open" });
-
-    // State
-    this._items = [];
-    this._checked = new Set();
-    this._savedItems = null;
-    this._savedChecked = null;
-    this._onApply = null;
-
-    // Drag state
-    this._ghost = null;
-    this._dragSrcIdx = null;
-    this._dropTargetIdx = null;
-    this._dropPosition = null;
-    this._ghostOffX = 0;
-    this._ghostOffY = 0;
-    this._autoScrollRAF = null;
-    this._lastPointerY = 0;
-    this._lastPointerX = 0;
-    this._SCROLL_ZONE = 72;
-    this._SCROLL_SPEED = 0.4;
-
-    // Bound handlers
-    this._onMove = this._onMove.bind(this);
-    this._onUp = this._onUp.bind(this);
-
-    this.shadowRoot.innerHTML = `
-      <style>
-        :host {
-          --ink: #0f0f0f;
-          --paper: #f5f3ef;
-          --muted: #6b6b6b;
-          --rule: #e2dfd8;
-          --accent: #1a56db;
-          --accent-light: #e8effd;
-          --card: #ffffff;
-        }
-
-        * { box-sizing: border-box; margin: 0; padding: 0; }
-
-        dialog {
-          border: none;
-          border-radius: var(--modal-border-radius, 0.75rem);
-          padding: 0;
-          margin: auto;
-          width: 100%;
-          max-width: 420px;
-          max-height: min(640px, calc(100vh - 32px));
-          box-shadow: var(--modal-shadow, 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04));
-          animation: slideIn var(--modal-animation-duration, 0.2s) ease-out;
-          overflow: hidden;
-          font-family: system-ui, -apple-system, sans-serif;
-          background: var(--card);
-          -webkit-user-select: none;
-          -webkit-touch-callout: none;
-          -webkit-tap-highlight-color: transparent;
-        }
-
-        dialog[open] {
-          display: flex;
-          flex-direction: column;
-          height: min(640px, calc(100vh - 32px));
-        }
-
-        dialog::backdrop {
-          background: var(--modal-backdrop-bg, rgba(0, 0, 0, 0.5));
-          backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-          -webkit-backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-          animation: fadeIn var(--modal-animation-duration, 0.2s) ease-out;
-        }
-
-        @keyframes slideIn {
-          from {
-            opacity: 0;
-            transform: translateY(-20px) scale(0.95);
-          }
-          to {
-            opacity: 1;
-            transform: translateY(0) scale(1);
-          }
-        }
-
-        @keyframes fadeIn {
-          from { opacity: 0; }
-          to { opacity: 1; }
-        }
-
-        .modal-header {
-          padding: 20px 24px 16px;
-          border-bottom: 1px solid var(--rule);
-          display: flex;
-          align-items: center;
-          justify-content: space-between;
-          flex-shrink: 0;
-        }
-
-        .modal-title {
-          font-size: 1rem;
-          font-weight: 600;
-        }
-
-        .modal-meta {
-          font-family: ui-monospace, monospace;
-          font-size: 0.7rem;
-          color: var(--muted);
-          background: var(--paper);
-          padding: 3px 9px;
-          border-radius: 20px;
-        }
-
-        .list-toolbar {
-          padding: 6px 24px;
-          border-bottom: 1px solid var(--rule);
-          display: flex;
-          gap: 12px;
-          flex-shrink: 0;
-        }
-
-        .list-toolbar button {
-          background: var(--accent-light);
-          border: 1px solid var(--rule);
-          border-radius: 4px;
-          font-family: inherit;
-          font-size: 0.75rem;
-          color: var(--accent);
-          cursor: pointer;
-          padding: 3px 10px;
-          transition: background 0.12s, color 0.12s;
-        }
-        .list-toolbar button:hover { background: var(--accent); color: white; }
-
-        .list-wrap {
-          flex: 1;
-          overflow-y: auto;
-          overflow-x: hidden;
-          position: relative;
-          overscroll-behavior: contain;
-          -webkit-overflow-scrolling: touch;
-        }
-
-        .list-wrap::before,
-        .list-wrap::after {
-          content: '';
-          position: sticky;
-          display: block;
-          left: 0; right: 0;
-          height: 20px;
-          pointer-events: none;
-          z-index: 5;
-          transition: opacity 0.2s;
-        }
-        .list-wrap::before {
-          top: 0;
-          background: linear-gradient(to bottom, rgba(255,255,255,0.9), transparent);
-        }
-        .list-wrap::after {
-          bottom: 0;
-          background: linear-gradient(to top, rgba(255,255,255,0.9), transparent);
-          margin-top: -20px;
-        }
-
-        .scroll-zone {
-          position: absolute;
-          left: 0; right: 0;
-          height: 72px;
-          pointer-events: none;
-          z-index: 10;
-        }
-        .scroll-zone-top { top: 0; }
-        .scroll-zone-bot { bottom: 0; }
-
-        .drag-list {
-          list-style: none;
-          padding: 4px 0;
-        }
-
-        .drag-item {
-          display: flex;
-          align-items: center;
-          background: white;
-          border-bottom: 1px solid var(--rule);
-          user-select: none;
-          -webkit-user-select: none;
-          -webkit-touch-callout: none;
-          position: relative;
-          transition: background 0.08s;
-        }
-
-        .drag-item:last-child { border-bottom: none; }
-
-        .drag-handle {
-          display: flex;
-          align-items: center;
-          justify-content: center;
-          width: 48px;
-          height: 48px;
-          flex-shrink: 0;
-          cursor: grab;
-          color: #c8c4bc;
-          touch-action: none;
-          transition: color 0.15s;
-        }
-
-        .drag-handle:hover { color: var(--accent); }
-        .drag-handle svg { pointer-events: none; display: block; }
-
-        .drag-item-content {
-          display: flex;
-          align-items: center;
-          flex: 1;
-          min-width: 0;
-          cursor: pointer;
-        }
-
-        .drag-item-check {
-          display: flex;
-          align-items: center;
-          width: 32px;
-          height: 48px;
-          flex-shrink: 0;
-        }
-
-        .drag-item-check input[type="checkbox"] {
-          width: 16px;
-          height: 16px;
-          accent-color: var(--accent);
-          cursor: pointer;
-        }
-
-        .drag-item-label {
-          flex: 1;
-          font-size: 0.9rem;
-          line-height: 48px;
-          padding-right: 16px;
-          white-space: nowrap;
-          overflow: hidden;
-          text-overflow: ellipsis;
-          cursor: default;
-        }
-
-        .drag-item.is-dragging {
-          opacity: 0;
-        }
-
-        .drop-indicator {
-          position: absolute;
-          left: 48px;
-          right: 0;
-          height: 2px;
-          background: var(--accent);
-          border-radius: 99px;
-          pointer-events: none;
-          z-index: 20;
-          display: none;
-        }
-        .drop-indicator.top { top: -1px; display: block; }
-        .drop-indicator.bottom { bottom: -1px; display: block; }
-
-        .drag-ghost {
-          position: fixed;
-          pointer-events: none;
-          z-index: 9999;
-          background: white;
-          border-radius: 6px;
-          box-shadow: 0 8px 32px rgba(0,0,0,0.18), 0 2px 8px rgba(0,0,0,0.1);
-          display: flex;
-          align-items: center;
-          border: 1.5px solid var(--accent-light);
-          opacity: 0.97;
-          will-change: transform;
-          font-family: system-ui, -apple-system, sans-serif;
-        }
-
-        .scroll-pulse {
-          position: absolute;
-          left: 50%;
-          transform: translateX(-50%);
-          width: 32px;
-          height: 32px;
-          border-radius: 50%;
-          background: var(--accent);
-          opacity: 0;
-          pointer-events: none;
-          z-index: 10;
-          transition: opacity 0.15s;
-        }
-        .scroll-pulse.top { top: 8px; }
-        .scroll-pulse.bot { bottom: 8px; }
-        .scroll-pulse.active {
-          opacity: 0.18;
-          animation: pulse 0.8s ease-in-out infinite;
-        }
-
-        @keyframes pulse {
-          0%, 100% { transform: translateX(-50%) scale(1); opacity: 0.18; }
-          50% { transform: translateX(-50%) scale(1.5); opacity: 0.07; }
-        }
-
-        .modal-footer {
-          padding: 14px 20px;
-          border-top: 1px solid var(--rule);
-          display: flex;
-          align-items: center;
-          gap: 10px;
-          flex-shrink: 0;
-          background: var(--paper);
-        }
-
-        .footer-info {
-          flex: 1;
-          font-family: ui-monospace, monospace;
-          font-size: 0.68rem;
-          color: var(--muted);
-        }
-
-        .btn {
-          border: none;
-          border-radius: 5px;
-          padding: 9px 20px;
-          font-size: 0.85rem;
-          font-weight: 500;
-          cursor: pointer;
-          touch-action: manipulation;
-          font-family: inherit;
-          transition: background 0.12s;
-        }
-
-        .btn-primary {
-          background: var(--accent);
-          color: white;
-        }
-        .btn-primary:hover { background: #1448c0; }
-
-        .btn-ghost {
-          background: transparent;
-          color: var(--muted);
-          border: 1px solid var(--rule);
-        }
-        .btn-ghost:hover { background: var(--rule); color: var(--ink); }
-
-        .list-wrap::-webkit-scrollbar { width: 5px; }
-        .list-wrap::-webkit-scrollbar-track { background: transparent; }
-        .list-wrap::-webkit-scrollbar-thumb { background: var(--rule); border-radius: 99px; }
-
-        input, textarea { -webkit-user-select: auto; user-select: auto; }
-      </style>
-
-      <dialog aria-labelledby="modalTitle">
-          <div class="modal-header">
-            <span class="modal-title" id="modalTitle">Choose columns</span>
-            <span class="modal-meta" id="selectedCount"></span>
-          </div>
-          <div class="list-toolbar">
-            <button id="selectAllBtn">Select all</button>
-            <button id="deselectAllBtn">Deselect all</button>
-          </div>
-          <div class="list-wrap" id="listWrap">
-            <div class="scroll-pulse top" id="pulseTop"></div>
-            <div class="scroll-pulse bot" id="pulseBot"></div>
-            <ul class="drag-list" id="dragList"></ul>
-          </div>
-          <div class="modal-footer">
-            <span class="footer-info" id="footerInfo"></span>
-            <button class="btn btn-ghost" id="cancelBtn">Cancel</button>
-            <button class="btn btn-primary" id="applyBtn">Apply</button>
-          </div>
-      </dialog>
-    `;
-
-    // DOM refs
-    this._dialog = this.shadowRoot.querySelector("dialog");
-    this._listWrap = this.shadowRoot.getElementById("listWrap");
-    this._dragList = this.shadowRoot.getElementById("dragList");
-    this._pulseTop = this.shadowRoot.getElementById("pulseTop");
-    this._pulseBot = this.shadowRoot.getElementById("pulseBot");
-    this._selectAllBtn = this.shadowRoot.getElementById("selectAllBtn");
-    this._deselectAllBtn = this.shadowRoot.getElementById("deselectAllBtn");
-    this._cancelBtn = this.shadowRoot.getElementById("cancelBtn");
-    this._applyBtn = this.shadowRoot.getElementById("applyBtn");
-    this._countEl = this.shadowRoot.getElementById("selectedCount");
-    this._footerEl = this.shadowRoot.getElementById("footerInfo");
-
-    // Event listeners
-    this._selectAllBtn.addEventListener("click", () => this._selectAll());
-    this._deselectAllBtn.addEventListener("click", () => this._deselectAll());
-    this._cancelBtn.addEventListener("click", () => this._close());
-    this._applyBtn.addEventListener("click", () => this._apply());
-    this._dialog.addEventListener("click", (e) => {
-      if (e.target === this._dialog) this._close();
-    });
-    this._dialog.addEventListener("cancel", (e) => {
-      e.preventDefault();
-      this._close();
-    });
-  }
-
-  /**
-   * Open the column chooser dialog.
-   * @param {Object} opts
-   * @param {string[]} opts.columns - All available column names, in display order.
-   * @param {string[]} opts.selected - Column names that should be pre-checked.
-   * @param {function(string[]): void} opts.onApply - Called with the selected columns in order when Apply is clicked.
-   */
-  open({ columns, selected = [], onApply }) {
-    this._items = [...columns];
-    this._checked = new Set(selected);
-    this._onApply = onApply || null;
-
-    // Save state for cancel/restore
-    this._savedItems = [...this._items];
-    this._savedChecked = new Set(this._checked);
-
-    this._render();
-    this._dialog.showModal();
-  }
-
-  // ── Internal methods ──
-
-  _close() {
-    this._items = this._savedItems ? [...this._savedItems] : this._items;
-    this._checked = this._savedChecked
-      ? new Set(this._savedChecked)
-      : this._checked;
-    this._dialog.close();
-  }
-
-  _selectAll() {
-    this._items.forEach((col) => this._checked.add(col));
-    this._dragList.querySelectorAll('input[type="checkbox"]').forEach((cb) => {
-      cb.checked = true;
-    });
-    this._updateCounts();
-  }
-
-  _deselectAll() {
-    this._checked.clear();
-    this._dragList.querySelectorAll('input[type="checkbox"]').forEach((cb) => {
-      cb.checked = false;
-    });
-    this._updateCounts();
-  }
-
-  _apply() {
-    const selected = this._items.filter((col) => this._checked.has(col));
-    this._dialog.close();
-    if (this._onApply) {
-      this._onApply(selected);
-    }
-  }
-
-  _render() {
-    this._dragList.innerHTML = "";
-    this._items.forEach((col, i) => {
-      const li = document.createElement("li");
-      li.className = "drag-item";
-      li.dataset.idx = i;
-      li.innerHTML = `
-        <span class="drag-handle" aria-label="Drag to reorder">
-          <svg width="12" height="18" viewBox="0 0 12 18" fill="currentColor">
-            <circle cx="3.5" cy="3.5" r="1.8"/>
-            <circle cx="8.5" cy="3.5" r="1.8"/>
-            <circle cx="3.5" cy="9" r="1.8"/>
-            <circle cx="8.5" cy="9" r="1.8"/>
-            <circle cx="3.5" cy="14.5" r="1.8"/>
-            <circle cx="8.5" cy="14.5" r="1.8"/>
-          </svg>
-        </span>
-        <label class="drag-item-content">
-          <span class="drag-item-check">
-            <input type="checkbox" ${this._checked.has(col) ? "checked" : ""}>
-          </span>
-          <span class="drag-item-label">${col}</span>
-        </label>
-        <div class="drop-indicator"></div>
-      `;
-
-      li.querySelector("input").addEventListener("change", (e) => {
-        e.target.checked ? this._checked.add(col) : this._checked.delete(col);
-        this._updateCounts();
-      });
-
-      li.querySelector(".drag-handle").addEventListener("pointerdown", (e) =>
-        this._startDrag(e, i),
-      );
-      this._dragList.appendChild(li);
-    });
-
-    this._updateCounts();
-  }
-
-  _updateCounts() {
-    const n = this._checked.size;
-    this._countEl.textContent = `${n} of ${this._items.length} selected`;
-    this._footerEl.textContent = `${this._items.length} columns`;
-  }
-
-  // ── Drag engine ──
-
-  _startDrag(e, idx) {
-    e.preventDefault();
-    this._dragSrcIdx = idx;
-
-    const srcEl = this._dragList.children[idx];
-    const rect = srcEl.getBoundingClientRect();
-
-    this._ghostOffX = e.clientX - rect.left;
-    this._ghostOffY = e.clientY - rect.top;
-
-    // Build ghost inside shadow DOM
-    this._ghost = document.createElement("div");
-    this._ghost.className = "drag-ghost";
-    this._ghost.style.width = rect.width + "px";
-    this._ghost.style.height = rect.height + "px";
-    this._ghost.innerHTML = srcEl.innerHTML;
-    this._ghost.querySelector(".drop-indicator")?.remove();
-    const h = this._ghost.querySelector(".drag-handle");
-    if (h) h.style.color = "var(--accent)";
-    this.shadowRoot.appendChild(this._ghost);
-
-    srcEl.classList.add("is-dragging");
-    this._positionGhost(e.clientX, e.clientY);
-
-    document.addEventListener("pointermove", this._onMove);
-    document.addEventListener("pointerup", this._onUp);
-    document.addEventListener("pointercancel", this._onUp);
-  }
-
-  _positionGhost(cx, cy) {
-    this._ghost.style.left = cx - this._ghostOffX + "px";
-    this._ghost.style.top = cy - this._ghostOffY + "px";
-  }
-
-  _onMove(e) {
-    this._lastPointerX = e.clientX;
-    this._lastPointerY = e.clientY;
-    this._positionGhost(e.clientX, e.clientY);
-    this._updateDropTarget(e.clientY);
-    this._updateAutoScroll(e.clientY);
-  }
-
-  _onUp() {
-    document.removeEventListener("pointermove", this._onMove);
-    document.removeEventListener("pointerup", this._onUp);
-    document.removeEventListener("pointercancel", this._onUp);
-
-    this._stopAutoScroll();
-
-    const noMove =
-      this._dropTargetIdx === null || this._dropTargetIdx === this._dragSrcIdx;
-    this._clearDropIndicators();
-
-    let dest = null;
-    if (!noMove) {
-      const moved = this._items.splice(this._dragSrcIdx, 1)[0];
-      dest = this._dropTargetIdx;
-      if (this._dropPosition === "after") dest++;
-      if (dest > this._dragSrcIdx) dest--;
-      this._items.splice(dest, 0, moved);
-    }
-
-    this._dragSrcIdx = null;
-    this._dropTargetIdx = null;
-    this._dropPosition = null;
-
-    const g = this._ghost;
-    this._ghost = null;
-
-    if (noMove) {
-      if (g) g.remove();
-      this._render();
-      return;
-    }
-
-    this._render();
-
-    if (g && dest !== null) {
-      const landedEl = this._dragList.children[dest];
-      if (landedEl) {
-        landedEl.style.opacity = "0";
-        const r = landedEl.getBoundingClientRect();
-        g.getBoundingClientRect();
-        g.style.transition =
-          "left 0.15s cubic-bezier(0.22, 1, 0.36, 1), top 0.15s cubic-bezier(0.22, 1, 0.36, 1), box-shadow 0.15s, opacity 0.1s 0.1s";
-        g.style.left = r.left + "px";
-        g.style.top = r.top + "px";
-        g.style.boxShadow = "0 1px 4px rgba(0,0,0,0.08)";
-        g.style.opacity = "0";
-        setTimeout(() => {
-          g.remove();
-          if (landedEl) landedEl.style.opacity = "";
-        }, 160);
-      } else {
-        g.remove();
-      }
-    } else if (g) {
-      g.remove();
-    }
-  }
-
-  _updateDropTarget(clientY) {
-    this._clearDropIndicators();
-    const listItems = [
-      ...this._dragList.querySelectorAll(".drag-item:not(.is-dragging)"),
-    ];
-    if (!listItems.length) return;
-
-    let best = null,
-      bestDist = Infinity;
-    listItems.forEach((li) => {
-      const r = li.getBoundingClientRect();
-      const mid = r.top + r.height / 2;
-      const dist = Math.abs(clientY - mid);
-      if (dist < bestDist) {
-        bestDist = dist;
-        best = li;
-      }
-    });
-
-    if (!best) return;
-    const r = best.getBoundingClientRect();
-    const mid = r.top + r.height / 2;
-    const above = clientY < mid;
-    const indic = best.querySelector(".drop-indicator");
-
-    this._dropTargetIdx = parseInt(best.dataset.idx);
-    this._dropPosition = above ? "before" : "after";
-
-    if (indic) {
-      indic.className = "drop-indicator " + (above ? "top" : "bottom");
-    }
-  }
-
-  _clearDropIndicators() {
-    this._dragList.querySelectorAll(".drop-indicator").forEach((el) => {
-      el.className = "drop-indicator";
-    });
-  }
-
-  _updateAutoScroll(clientY) {
-    const rect = this._listWrap.getBoundingClientRect();
-    const relY = clientY - rect.top;
-    const distTop = relY;
-    const distBot = rect.height - relY;
-
-    const inTop = distTop < this._SCROLL_ZONE && distTop >= 0;
-    const inBot = distBot < this._SCROLL_ZONE && distBot >= 0;
-
-    this._pulseTop.classList.toggle("active", inTop);
-    this._pulseBot.classList.toggle("active", inBot);
-
-    if ((inTop || inBot) && !this._autoScrollRAF) {
-      let lastTime = null;
-      const loop = (ts) => {
-        if (!this._ghost) {
-          this._stopAutoScroll();
-          return;
-        }
-        if (lastTime !== null) {
-          const dt = ts - lastTime;
-          const rect2 = this._listWrap.getBoundingClientRect();
-          const relY2 = this._lastPointerY - rect2.top;
-          const dTop = relY2;
-          const dBot = rect2.height - relY2;
-
-          if (dTop < this._SCROLL_ZONE && dTop >= 0) {
-            const factor = 1 - dTop / this._SCROLL_ZONE;
-            this._listWrap.scrollTop -= this._SCROLL_SPEED * dt * factor * 2.5;
-          } else if (dBot < this._SCROLL_ZONE && dBot >= 0) {
-            const factor = 1 - dBot / this._SCROLL_ZONE;
-            this._listWrap.scrollTop += this._SCROLL_SPEED * dt * factor * 2.5;
-          } else {
-            this._stopAutoScroll();
-            return;
-          }
-          this._updateDropTarget(this._lastPointerY);
-        }
-        lastTime = ts;
-        this._autoScrollRAF = requestAnimationFrame(loop);
-      };
-      this._autoScrollRAF = requestAnimationFrame(loop);
-    }
-
-    if (!inTop && !inBot) this._stopAutoScroll();
-  }
-
-  _stopAutoScroll() {
-    if (this._autoScrollRAF) {
-      cancelAnimationFrame(this._autoScrollRAF);
-      this._autoScrollRAF = null;
-    }
-    this._pulseTop.classList.remove("active");
-    this._pulseBot.classList.remove("active");
-  }
-}
-
-customElements.define("column-chooser", ColumnChooser);

datasette/static/datasette-manager.js

@@ -82,19 +82,6 @@ const datasetteManager = {
     return columnActions;
   },
 
-  makeJumpSections: (context) => {
-    let jumpSections = [];
-
-    datasetteManager.plugins.forEach((plugin) => {
-      if (plugin.makeJumpSections) {
-        const sections = plugin.makeJumpSections(context) || [];
-        jumpSections.push(...sections);
-      }
-    });
-
-    return jumpSections;
-  },
-
   /**
    * In MVP, each plugin can only have 1 instance.
    * In future, panels could be repeated. We omit that for now since so many plugins depend on
@@ -106,12 +93,12 @@ const datasetteManager = {
    */
   renderAboveTablePanel: () => {
     const aboveTablePanel = document.querySelector(
-      DOM_SELECTORS.aboveTablePanel,
+      DOM_SELECTORS.aboveTablePanel
     );
 
     if (!aboveTablePanel) {
       console.warn(
-        "This page does not have a table, the renderAboveTablePanel cannot be used.",
+        "This page does not have a table, the renderAboveTablePanel cannot be used."
       );
       return;
     }
@@ -205,6 +192,7 @@ const initializeDatasette = () => {
   // DATASETTE_EVENTS.INIT event to avoid the habit of reading from the window.
 
   window.__DATASETTE__ = datasetteManager;
+  console.debug("Datasette Manager Created!");
 
   const initDatasetteEvent = new CustomEvent(DATASETTE_EVENTS.INIT, {
     detail: datasetteManager,

datasette/static/json-format-highlight-1.0.1.js

@@ -7,8 +7,8 @@ MIT Licensed
   typeof exports === "object" && typeof module !== "undefined"
     ? (module.exports = factory())
     : typeof define === "function" && define.amd
-      ? define(factory)
-      : (global.jsonFormatHighlight = factory());
+    ? define(factory)
+    : (global.jsonFormatHighlight = factory());
 })(this, function () {
   "use strict";
 
@@ -42,13 +42,13 @@ MIT Licensed
           color = /true/.test(match)
             ? colors.trueColor
             : /false/.test(match)
-              ? colors.falseColor
-              : /null/.test(match)
-                ? colors.nullColor
-                : color;
+            ? colors.falseColor
+            : /null/.test(match)
+            ? colors.nullColor
+            : color;
         }
         return '<span style="color: ' + color + '">' + match + "</span>";
-      },
+      }
     );
   }
 

datasette/static/mobile-column-actions.js

@@ -1,318 +0,0 @@
-var MOBILE_COLUMN_BREAKPOINT = 576;
-var MOBILE_COLUMN_DIALOG_ID = "mobile-column-actions-dialog";
-var MOBILE_COLUMN_DIALOG_TITLE_ID = "mobile-column-actions-title";
-
-function mobileColumnHeaders(manager) {
-  return Array.from(
-    document.querySelectorAll(manager.selectors.tableHeaders),
-  ).filter((th) => th.dataset.column && th.dataset.isLinkColumn !== "1");
-}
-
-function mobileColumnMetaText(th) {
-  var parts = [];
-  if (th.dataset.columnType) {
-    parts.push(th.dataset.columnType);
-  }
-  if (th.dataset.isPk === "1") {
-    parts.push("pk");
-  }
-  if (th.dataset.columnNotNull === "1") {
-    parts.push("not null");
-  }
-  return parts.join(", ");
-}
-
-function createMobileColumnActionNode(itemConfig, closeDialog) {
-  var actionNode;
-  if (itemConfig.href) {
-    actionNode = document.createElement("a");
-    actionNode.href = itemConfig.href;
-  } else {
-    actionNode = document.createElement("button");
-    actionNode.type = "button";
-  }
-  actionNode.textContent = itemConfig.label;
-
-  if (itemConfig.onClick) {
-    actionNode.addEventListener("click", function (ev) {
-      try {
-        itemConfig.onClick.call(actionNode, ev);
-      } finally {
-        closeDialog({ restoreFocus: false });
-      }
-    });
-  }
-
-  return actionNode;
-}
-
-function initMobileColumnActions(manager) {
-  var triggerButton = document.querySelector(".column-actions-mobile");
-  if (!triggerButton) {
-    return;
-  }
-
-  if (
-    !window.URLSearchParams ||
-    !window.HTMLDialogElement ||
-    !manager.columnActions
-  ) {
-    triggerButton.style.display = "none";
-    return;
-  }
-
-  if (!mobileColumnHeaders(manager).length) {
-    triggerButton.style.display = "none";
-    return;
-  }
-
-  var dialog = document.createElement("dialog");
-  dialog.className = "mobile-column-actions-dialog";
-  dialog.id = MOBILE_COLUMN_DIALOG_ID;
-  dialog.setAttribute("aria-labelledby", MOBILE_COLUMN_DIALOG_TITLE_ID);
-  dialog.innerHTML = `
-    <div class="modal-header">
-      <span class="modal-title" id="${MOBILE_COLUMN_DIALOG_TITLE_ID}">Column actions</span>
-      <span class="modal-meta"></span>
-    </div>
-    <div class="list-wrap mobile-column-list"></div>
-    <div class="modal-footer">
-      <span class="footer-info">Tap a column to reveal actions.</span>
-      <button type="button" class="btn btn-ghost mobile-column-actions-done">Done</button>
-    </div>
-  `;
-  document.body.appendChild(dialog);
-
-  triggerButton.setAttribute("aria-haspopup", "dialog");
-  triggerButton.setAttribute("aria-controls", MOBILE_COLUMN_DIALOG_ID);
-  triggerButton.setAttribute("aria-expanded", "false");
-
-  var countEl = dialog.querySelector(".modal-meta");
-  var listWrap = dialog.querySelector(".mobile-column-list");
-  var doneButton = dialog.querySelector(".mobile-column-actions-done");
-  var expandedSectionId = null;
-  var shouldRestoreFocus = true;
-
-  function updateExpandedSection() {
-    Array.from(dialog.querySelectorAll(".col-header")).forEach((button) => {
-      var controlsId = button.getAttribute("aria-controls");
-      var actionList = dialog.querySelector("#" + controlsId);
-      var isExpanded = controlsId === expandedSectionId;
-      button.setAttribute("aria-expanded", isExpanded ? "true" : "false");
-      actionList.hidden = !isExpanded;
-      actionList.classList.toggle("expanded", isExpanded);
-    });
-  }
-
-  function scrollExpandedSectionIntoView(section) {
-    var sectionTop = section.offsetTop;
-    var sectionBottom = sectionTop + section.offsetHeight;
-    var visibleTop = listWrap.scrollTop;
-    var visibleBottom = visibleTop + listWrap.clientHeight;
-    var sectionHeight = section.offsetHeight;
-
-    if (sectionTop < visibleTop) {
-      listWrap.scrollTop = sectionTop;
-      return;
-    }
-
-    if (sectionBottom <= visibleBottom) {
-      return;
-    }
-
-    if (sectionHeight <= listWrap.clientHeight) {
-      listWrap.scrollTop = sectionBottom - listWrap.clientHeight;
-    } else {
-      listWrap.scrollTop = sectionTop;
-    }
-  }
-
-  function closeDialog(options) {
-    options = options || {};
-    shouldRestoreFocus = options.restoreFocus !== false;
-    if (dialog.open) {
-      dialog.close();
-    } else {
-      triggerButton.setAttribute("aria-expanded", "false");
-      if (shouldRestoreFocus) {
-        triggerButton.focus();
-      }
-    }
-  }
-
-  function renderDialog() {
-    var headers = mobileColumnHeaders(manager);
-    if (!headers.length) {
-      closeDialog({ restoreFocus: false });
-      triggerButton.style.display = "none";
-      return false;
-    }
-
-    if (
-      !headers.some(
-        (_th, index) => `mobile-column-actions-${index}` === expandedSectionId,
-      )
-    ) {
-      expandedSectionId = null;
-    }
-
-    countEl.textContent = `${headers.length} column${
-      headers.length === 1 ? "" : "s"
-    }`;
-    listWrap.innerHTML = "";
-
-    if (manager.columnActions.shouldShowShowAllColumns()) {
-      var topActions = document.createElement("div");
-      topActions.className = "mobile-column-top-actions";
-
-      var showAllColumns = document.createElement("a");
-      showAllColumns.className = "btn btn-ghost mobile-column-top-action";
-      showAllColumns.href = manager.columnActions.showAllColumnsUrl();
-      showAllColumns.textContent = "Show all columns";
-
-      topActions.appendChild(showAllColumns);
-      listWrap.appendChild(topActions);
-    }
-
-    headers.forEach((th, index) => {
-      var sectionId = `mobile-column-actions-${index}`;
-      var actionState = manager.columnActions.buildColumnActionState(th, {
-        includeChooseColumns: false,
-        includeShowAllColumns: false,
-      });
-      var section = document.createElement("section");
-      section.className = "mobile-column-section";
-
-      var headerButton = document.createElement("button");
-      headerButton.type = "button";
-      headerButton.className = "col-header";
-      headerButton.setAttribute("aria-controls", sectionId);
-      headerButton.setAttribute("aria-expanded", "false");
-
-      var headerText = document.createElement("span");
-      headerText.className = "mobile-column-header-text";
-
-      var name = document.createElement("span");
-      name.className = "mobile-column-name";
-      name.textContent = th.dataset.column;
-      headerText.appendChild(name);
-
-      var metaText = mobileColumnMetaText(th);
-      if (metaText) {
-        var meta = document.createElement("span");
-        meta.className = "mobile-column-meta";
-        meta.textContent = metaText;
-        headerText.appendChild(meta);
-      }
-
-      var chevron = document.createElement("span");
-      chevron.className = "mobile-column-chevron";
-      chevron.setAttribute("aria-hidden", "true");
-      chevron.textContent = "▾";
-
-      headerButton.appendChild(headerText);
-      headerButton.appendChild(chevron);
-      headerButton.addEventListener("click", function () {
-        expandedSectionId = expandedSectionId === sectionId ? null : sectionId;
-        updateExpandedSection();
-        if (expandedSectionId === sectionId) {
-          scrollExpandedSectionIntoView(section);
-        }
-      });
-
-      var actionContainer = document.createElement("div");
-      actionContainer.id = sectionId;
-      actionContainer.className = "col-actions";
-      actionContainer.hidden = true;
-
-      if (actionState.columnDescription) {
-        var description = document.createElement("p");
-        description.className = "mobile-column-description";
-        description.textContent = actionState.columnDescription;
-        actionContainer.appendChild(description);
-      }
-
-      if (actionState.actionItems.length) {
-        var actionList = document.createElement("ul");
-        actionState.actionItems.forEach((itemConfig) => {
-          var actionItem = document.createElement("li");
-          actionItem.appendChild(
-            createMobileColumnActionNode(itemConfig, closeDialog),
-          );
-          actionList.appendChild(actionItem);
-        });
-        actionContainer.appendChild(actionList);
-      } else {
-        var noActions = document.createElement("p");
-        noActions.className = "mobile-column-no-actions";
-        noActions.textContent = "No actions available";
-        actionContainer.appendChild(noActions);
-      }
-
-      section.appendChild(headerButton);
-      section.appendChild(actionContainer);
-      listWrap.appendChild(section);
-    });
-
-    updateExpandedSection();
-    return true;
-  }
-
-  function openDialog() {
-    if (window.innerWidth > MOBILE_COLUMN_BREAKPOINT) {
-      return;
-    }
-    if (!renderDialog()) {
-      return;
-    }
-    if (!dialog.open) {
-      dialog.showModal();
-    }
-    triggerButton.setAttribute("aria-expanded", "true");
-    var focusTarget =
-      dialog.querySelector(".mobile-column-top-action") ||
-      dialog.querySelector(".col-header") ||
-      doneButton;
-    focusTarget.focus();
-  }
-
-  triggerButton.addEventListener("click", function () {
-    if (dialog.open) {
-      closeDialog();
-    } else {
-      openDialog();
-    }
-  });
-
-  doneButton.addEventListener("click", function () {
-    closeDialog();
-  });
-
-  dialog.addEventListener("click", function (ev) {
-    if (ev.target === dialog) {
-      closeDialog();
-    }
-  });
-
-  dialog.addEventListener("cancel", function (ev) {
-    ev.preventDefault();
-    closeDialog();
-  });
-
-  dialog.addEventListener("close", function () {
-    triggerButton.setAttribute("aria-expanded", "false");
-    if (shouldRestoreFocus) {
-      triggerButton.focus();
-    }
-  });
-
-  window.addEventListener("resize", function () {
-    if (window.innerWidth > MOBILE_COLUMN_BREAKPOINT && dialog.open) {
-      closeDialog({ restoreFocus: false });
-    }
-  });
-}
-
-document.addEventListener("datasette_init", function (evt) {
-  initMobileColumnActions(evt.detail);
-});

datasette/static/navigation-search.js

@@ -1,910 +0,0 @@
-let navigationSearchInstanceCounter = 0;
-
-class NavigationSearch extends HTMLElement {
-  constructor() {
-    super();
-    this.instanceId = ++navigationSearchInstanceCounter;
-    this.inputId = `navigation-search-input-${this.instanceId}`;
-    this.instructionsId = `navigation-search-instructions-${this.instanceId}`;
-    this.listboxId = `navigation-search-results-${this.instanceId}`;
-    this.recentHeadingId = `navigation-search-recent-${this.instanceId}`;
-    this.statusId = `navigation-search-status-${this.instanceId}`;
-    this.titleId = `navigation-search-title-${this.instanceId}`;
-    this.attachShadow({ mode: "open" });
-    this.selectedIndex = -1;
-    this.matches = [];
-    this.renderedMatches = [];
-    this.debounceTimer = null;
-    this.restoreFocusTarget = null;
-    this.shouldRestoreFocus = true;
-
-    this.render();
-    this.setupEventListeners();
-  }
-
-  render() {
-    this.shadowRoot.innerHTML = `
-            <style>
-                :host {
-                    display: contents;
-                }
-
-                dialog {
-                    border: none;
-                    border-radius: var(--modal-border-radius, 0.75rem);
-                    padding: 0;
-                    max-width: 90vw;
-                    width: 600px;
-                    max-height: 80vh;
-                    box-shadow: var(--modal-shadow, 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04));
-                    animation: slideIn var(--modal-animation-duration, 0.2s) ease-out;
-                }
-
-                dialog::backdrop {
-                    background: var(--modal-backdrop-bg, rgba(0, 0, 0, 0.5));
-                    backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-                    -webkit-backdrop-filter: var(--modal-backdrop-blur, blur(4px));
-                    animation: fadeIn var(--modal-animation-duration, 0.2s) ease-out;
-                }
-
-                @keyframes slideIn {
-                    from {
-                        opacity: 0;
-                        transform: translateY(-20px) scale(0.95);
-                    }
-                    to {
-                        opacity: 1;
-                        transform: translateY(0) scale(1);
-                    }
-                }
-
-                @keyframes fadeIn {
-                    from { opacity: 0; }
-                    to { opacity: 1; }
-                }
-
-                .search-container {
-                    display: flex;
-                    flex-direction: column;
-                }
-
-                .search-input-wrapper {
-                    padding: 1.25rem;
-                    border-bottom: 1px solid #e5e7eb;
-                    display: flex;
-                    gap: 0.5rem;
-                    align-items: center;
-                }
-
-                .search-input {
-                    width: 100%;
-                    flex: 1;
-                    min-width: 0;
-                    padding: 0.75rem 1rem;
-                    font-size: 1rem;
-                    border: 2px solid #e5e7eb;
-                    border-radius: 0.5rem;
-                    outline: none;
-                    transition: border-color 0.2s;
-                    box-sizing: border-box;
-                }
-
-                .search-input:focus {
-                    border-color: #2563eb;
-                }
-
-                .close-search {
-                    background: transparent;
-                    border: 1px solid transparent;
-                    border-radius: 0.375rem;
-                    color: #4b5563;
-                    cursor: pointer;
-                    flex: 0 0 auto;
-                    font: inherit;
-                    font-size: 1.5rem;
-                    height: 2.75rem;
-                    line-height: 1;
-                    width: 2.75rem;
-                }
-
-                .close-search:hover,
-                .close-search:focus {
-                    background-color: #f3f4f6;
-                    border-color: #d1d5db;
-                }
-
-                .results-container {
-                    overflow-y: auto;
-                    height: calc(80vh - 180px);
-                    padding: 0.5rem;
-                }
-
-                .results-list:empty {
-                    display: none;
-                }
-
-                .result-item {
-                    padding: 0.875rem 1rem;
-                    cursor: pointer;
-                    border-radius: 0.5rem;
-                    transition: background-color 0.15s;
-                    display: flex;
-                    align-items: center;
-                    gap: 0.75rem;
-                }
-
-                .result-item:hover {
-                    background-color: #f3f4f6;
-                }
-
-                .result-item.selected {
-                    background-color: #dbeafe;
-                }
-
-                .result-item > div {
-                    flex: 1;
-                    min-width: 0;
-                }
-
-                .jump-start-content {
-                    border-bottom: 1px solid #e5e7eb;
-                    margin-bottom: 0.5rem;
-                    padding: 0.5rem 0.5rem 1rem;
-                }
-
-                .jump-start-content:empty {
-                    display: none;
-                }
-
-                .result-name {
-                    font-weight: 500;
-                    color: #111827;
-                }
-
-                .result-label {
-                    font-size: 0.875rem;
-                    color: #4b5563;
-                }
-
-                .result-type {
-                    color: #4b5563;
-                    font-size: 0.75rem;
-                    font-weight: 600;
-                    text-transform: uppercase;
-                }
-
-                .result-url {
-                    font-size: 0.875rem;
-                    color: #6b7280;
-                }
-
-                .result-description {
-                    color: #374151;
-                    display: -webkit-box;
-                    font-size: 0.8125rem;
-                    line-height: 1.35;
-                    margin-top: 0.35rem;
-                    overflow: hidden;
-                    -webkit-box-orient: vertical;
-                    -webkit-line-clamp: 2;
-                }
-
-                .results-heading {
-                    color: #4b5563;
-                    font-size: 0.75rem;
-                    font-weight: 600;
-                    letter-spacing: 0;
-                    padding: 0.5rem 1rem 0.25rem;
-                    text-transform: uppercase;
-                }
-
-                .recent-actions {
-                    padding: 0.25rem 1rem 0.75rem;
-                }
-
-                .clear-recent {
-                    background: transparent;
-                    border: 0;
-                    color: #2563eb;
-                    cursor: pointer;
-                    font: inherit;
-                    font-size: 0.875rem;
-                    padding: 0;
-                }
-
-                .clear-recent:hover {
-                    text-decoration: underline;
-                }
-
-                .no-results {
-                    padding: 2rem;
-                    text-align: center;
-                    color: #6b7280;
-                }
-
-                .hint-text {
-                    padding: 0.75rem 1.25rem;
-                    font-size: 0.875rem;
-                    color: #6b7280;
-                    border-top: 1px solid #e5e7eb;
-                    display: flex;
-                    gap: 1rem;
-                    flex-wrap: wrap;
-                }
-
-                .hint-text kbd {
-                    background: #f3f4f6;
-                    padding: 0.125rem 0.375rem;
-                    border-radius: 0.25rem;
-                    font-size: 0.75rem;
-                    border: 1px solid #d1d5db;
-                    font-family: monospace;
-                }
-
-                .visually-hidden {
-                    border: 0;
-                    clip: rect(0 0 0 0);
-                    height: 1px;
-                    margin: -1px;
-                    overflow: hidden;
-                    padding: 0;
-                    position: absolute;
-                    white-space: nowrap;
-                    width: 1px;
-                }
-
-                /* Mobile optimizations */
-                @media (max-width: 640px) {
-                    dialog {
-                        width: 95vw;
-                        max-height: 85vh;
-                        border-radius: 0.5rem;
-                    }
-
-                    .search-input-wrapper {
-                        padding: 1rem;
-                    }
-
-                    .search-input {
-                        font-size: 16px; /* Prevents zoom on iOS */
-                    }
-
-                    .result-item {
-                        padding: 1rem 0.75rem;
-                    }
-
-                    .hint-text {
-                        font-size: 0.8rem;
-                        padding: 0.5rem 1rem;
-                    }
-                }
-            </style>
-
-            <dialog aria-modal="true" aria-labelledby="${this.titleId}">
-                <div class="search-container">
-                    <h2 id="${this.titleId}" class="visually-hidden">Jump to</h2>
-                    <p id="${this.instructionsId}" class="visually-hidden">Type to search. Use up and down arrow keys to move through results, Enter to select a result, and Escape to close this menu.</p>
-                    <div id="${this.statusId}" class="visually-hidden" aria-live="polite" aria-atomic="true"></div>
-                    <div class="search-input-wrapper">
-                        <input 
-                            id="${this.inputId}"
-                            type="text" 
-                            class="search-input" 
-                            placeholder="Jump to..."
-                            aria-label="Jump to"
-                            aria-describedby="${this.instructionsId}"
-                            role="combobox"
-                            aria-autocomplete="list"
-                            aria-controls="${this.listboxId}"
-                            aria-expanded="false"
-                            autocomplete="off"
-                            spellcheck="false"
-                        >
-                        <button type="button" class="close-search" aria-label="Close jump menu">&times;</button>
-                    </div>
-                    <div class="results-container"></div>
-                    <div class="hint-text">
-                        <span><kbd>↑</kbd> <kbd>↓</kbd> Navigate</span>
-                        <span><kbd>Enter</kbd> Select</span>
-                        <span><kbd>Esc</kbd> Close</span>
-                    </div>
-                </div>
-            </dialog>
-        `;
-  }
-
-  setupEventListeners() {
-    const dialog = this.shadowRoot.querySelector("dialog");
-    const input = this.shadowRoot.querySelector(".search-input");
-    const closeButton = this.shadowRoot.querySelector(".close-search");
-    const resultsContainer =
-      this.shadowRoot.querySelector(".results-container");
-
-    // Global keyboard listener for "/"
-    document.addEventListener("keydown", (e) => {
-      if (e.key === "/" && !this.isInputFocused() && !dialog.open) {
-        e.preventDefault();
-        this.openMenu();
-      }
-    });
-
-    document.addEventListener("click", (e) => {
-      const trigger = e.target.closest("[data-navigation-search-open]");
-      if (trigger) {
-        e.preventDefault();
-        const details = trigger.closest("details");
-        const restoreTarget = details?.querySelector("summary") || trigger;
-        details?.removeAttribute("open");
-        this.openMenu(restoreTarget);
-      }
-    });
-
-    // Input event
-    input.addEventListener("input", (e) => {
-      this.handleSearch(e.target.value);
-    });
-
-    // Keyboard navigation
-    input.addEventListener("keydown", (e) => {
-      if (e.key === "ArrowDown") {
-        e.preventDefault();
-        this.moveSelection(1);
-      } else if (e.key === "ArrowUp") {
-        e.preventDefault();
-        this.moveSelection(-1);
-      } else if (e.key === "Enter") {
-        e.preventDefault();
-        this.selectCurrentItem();
-      } else if (e.key === "Escape") {
-        this.closeMenu();
-      }
-    });
-
-    closeButton.addEventListener("click", () => {
-      this.closeMenu();
-    });
-
-    // Click on result item
-    resultsContainer.addEventListener("click", (e) => {
-      const clearRecent = e.target.closest("[data-clear-recent-items]");
-      if (clearRecent) {
-        e.preventDefault();
-        this.clearRecentItems();
-        return;
-      }
-
-      const item = e.target.closest(".result-item");
-      if (item) {
-        const index = parseInt(item.dataset.index);
-        this.selectItem(index);
-      }
-    });
-
-    // Close on backdrop click
-    dialog.addEventListener("click", (e) => {
-      if (e.target === dialog) {
-        this.closeMenu();
-      }
-    });
-
-    dialog.addEventListener("cancel", (e) => {
-      e.preventDefault();
-      this.closeMenu();
-    });
-
-    dialog.addEventListener("close", () => {
-      this.onMenuClosed();
-    });
-
-    // Initial load
-    this.loadInitialData();
-  }
-
-  isInputFocused() {
-    const activeElement = document.activeElement;
-    return (
-      activeElement &&
-      (activeElement.tagName === "INPUT" ||
-        activeElement.tagName === "TEXTAREA" ||
-        activeElement.isContentEditable)
-    );
-  }
-
-  setElementAttribute(element, name, value) {
-    if (!element) {
-      return;
-    }
-    if (typeof element.setAttribute === "function") {
-      element.setAttribute(name, value);
-    } else {
-      element[name] = String(value);
-    }
-  }
-
-  removeElementAttribute(element, name) {
-    if (!element) {
-      return;
-    }
-    if (typeof element.removeAttribute === "function") {
-      element.removeAttribute(name);
-    } else {
-      delete element[name];
-    }
-  }
-
-  focusRestoreTarget(trigger) {
-    if (trigger && typeof trigger.focus === "function") {
-      return trigger;
-    }
-    if (
-      document.activeElement &&
-      typeof document.activeElement.focus === "function"
-    ) {
-      return document.activeElement;
-    }
-    return null;
-  }
-
-  setNavigationTriggersExpanded(expanded) {
-    if (typeof document.querySelectorAll !== "function") {
-      return;
-    }
-    document
-      .querySelectorAll("[data-navigation-search-open]")
-      .forEach((trigger) => {
-        this.setElementAttribute(
-          trigger,
-          "aria-expanded",
-          expanded ? "true" : "false",
-        );
-      });
-  }
-
-  resultOptionId(index) {
-    return `${this.listboxId}-option-${index}`;
-  }
-
-  updateComboboxState() {
-    const dialog = this.shadowRoot.querySelector("dialog");
-    const input = this.shadowRoot.querySelector(".search-input");
-    const matches = this.renderedMatches || [];
-    this.setElementAttribute(
-      input,
-      "aria-expanded",
-      dialog && dialog.open && matches.length > 0 ? "true" : "false",
-    );
-
-    if (
-      dialog &&
-      dialog.open &&
-      this.selectedIndex >= 0 &&
-      this.selectedIndex < matches.length
-    ) {
-      this.setElementAttribute(
-        input,
-        "aria-activedescendant",
-        this.resultOptionId(this.selectedIndex),
-      );
-    } else {
-      this.removeElementAttribute(input, "aria-activedescendant");
-    }
-  }
-
-  setStatus(message) {
-    const status = this.shadowRoot.querySelector(`#${this.statusId}`);
-    if (status) {
-      status.textContent = message || "";
-    }
-  }
-
-  resultsStatus(count, truncated) {
-    if (truncated) {
-      return "More than 100 results. Keep typing to narrow the list.";
-    }
-    if (count === 0) {
-      return "No results found.";
-    }
-    if (count === 1) {
-      return "1 result.";
-    }
-    return `${count} results.`;
-  }
-
-  loadInitialData() {
-    const itemsAttr = this.getAttribute("items");
-    if (itemsAttr) {
-      try {
-        this.allItems = JSON.parse(itemsAttr);
-        this.matches = this.allItems;
-      } catch (e) {
-        console.error("Failed to parse items attribute:", e);
-        this.allItems = [];
-        this.matches = [];
-      }
-    }
-  }
-
-  handleSearch(query) {
-    clearTimeout(this.debounceTimer);
-    if (query.trim()) {
-      this.setStatus("Searching...");
-    } else {
-      this.setStatus("");
-    }
-
-    this.debounceTimer = setTimeout(() => {
-      const url = this.getAttribute("url");
-
-      if (url) {
-        // Fetch from API
-        this.fetchResults(url, query);
-      } else {
-        // Filter local items
-        this.filterLocalItems(query);
-      }
-    }, 200);
-  }
-
-  async fetchResults(url, query) {
-    try {
-      const searchUrl = `${url}?q=${encodeURIComponent(query)}`;
-      const response = await fetch(searchUrl);
-      const data = await response.json();
-      this.matches = data.matches || [];
-      this.selectedIndex = this.matches.length > 0 ? 0 : -1;
-      this.renderResults();
-      if (query.trim()) {
-        this.setStatus(this.resultsStatus(this.matches.length, data.truncated));
-      } else {
-        this.setStatus("");
-      }
-    } catch (e) {
-      console.error("Failed to fetch search results:", e);
-      this.matches = [];
-      this.renderResults();
-      this.setStatus("Search failed.");
-    }
-  }
-
-  filterLocalItems(query) {
-    if (!query.trim()) {
-      this.matches = this.allItems || [];
-    } else {
-      const lowerQuery = query.toLowerCase();
-      this.matches = (this.allItems || []).filter(
-        (item) =>
-          item.name.toLowerCase().includes(lowerQuery) ||
-          (item.display_name || "").toLowerCase().includes(lowerQuery) ||
-          item.url.toLowerCase().includes(lowerQuery),
-      );
-    }
-    this.selectedIndex = this.matches.length > 0 ? 0 : -1;
-    this.renderResults();
-    if (query.trim()) {
-      this.setStatus(this.resultsStatus(this.matches.length, false));
-    } else {
-      this.setStatus("");
-    }
-  }
-
-  recentItemsStorageKey() {
-    return "datasette.navigationSearch.recentItems";
-  }
-
-  loadRecentItems() {
-    if (typeof localStorage === "undefined") {
-      return [];
-    }
-
-    try {
-      const raw = localStorage.getItem(this.recentItemsStorageKey());
-      if (!raw) {
-        return [];
-      }
-      const parsed = JSON.parse(raw);
-      if (!Array.isArray(parsed)) {
-        return [];
-      }
-      return parsed
-        .filter((item) => item && item.name && item.url)
-        .map((item) => ({
-          name: String(item.name),
-          display_name: item.display_name ? String(item.display_name) : "",
-          url: String(item.url),
-          type: item.type ? String(item.type) : "",
-          description: item.description ? String(item.description) : "",
-        }))
-        .slice(0, 5);
-    } catch (e) {
-      return [];
-    }
-  }
-
-  saveRecentItem(match) {
-    if (
-      typeof localStorage === "undefined" ||
-      !match ||
-      !match.name ||
-      !match.url
-    ) {
-      return;
-    }
-
-    try {
-      const item = {
-        name: String(match.name),
-        display_name: match.display_name ? String(match.display_name) : "",
-        url: String(match.url),
-        type: match.type ? String(match.type) : "",
-        description: match.description ? String(match.description) : "",
-      };
-      const recentItems = this.loadRecentItems().filter(
-        (recentItem) => recentItem.url !== item.url,
-      );
-      localStorage.setItem(
-        this.recentItemsStorageKey(),
-        JSON.stringify([item, ...recentItems].slice(0, 5)),
-      );
-    } catch (e) {
-      // localStorage may be unavailable, full, or disabled.
-    }
-  }
-
-  clearRecentItems() {
-    if (typeof localStorage === "undefined") {
-      return;
-    }
-
-    try {
-      localStorage.removeItem(this.recentItemsStorageKey());
-    } catch (e) {
-      localStorage.setItem(this.recentItemsStorageKey(), "[]");
-    }
-    this.renderResults();
-    this.setStatus("Recent items cleared.");
-  }
-
-  jumpSections() {
-    const manager = window.__DATASETTE__;
-    if (!manager || typeof manager.makeJumpSections !== "function") {
-      return [];
-    }
-    const sections = manager.makeJumpSections({
-      navigationSearch: this,
-    });
-    return Array.isArray(sections)
-      ? sections.filter(
-          (section) => section && typeof section.render === "function",
-        )
-      : [];
-  }
-
-  jumpSectionsHtml(jumpSections) {
-    return jumpSections
-      .map((section, index) => {
-        const id = section.id
-          ? ` data-jump-section-id="${this.escapeHtml(section.id)}"`
-          : "";
-        return `<div class="jump-start-content" data-jump-section-index="${index}"${id}></div>`;
-      })
-      .join("");
-  }
-
-  renderJumpSections(container, jumpSections) {
-    jumpSections.forEach((section, index) => {
-      const node = container.querySelector(
-        `[data-jump-section-index="${index}"]`,
-      );
-      if (!node) {
-        return;
-      }
-      section.render(node, {
-        navigationSearch: this,
-        container,
-        input: this.shadowRoot.querySelector(".search-input"),
-      });
-    });
-  }
-
-  resultItemHtml(match, index) {
-    const displayName = match.display_name || match.name;
-    const label =
-      match.display_name && match.display_name !== match.name
-        ? `<div class="result-label">${this.escapeHtml(match.name)}</div>`
-        : "";
-    const type = match.type
-      ? `<div class="result-type">${this.escapeHtml(match.type)}</div>`
-      : "";
-    const description = match.description
-      ? `<div class="result-description">${this.escapeHtml(
-          match.description,
-        )}</div>`
-      : "";
-    return `
-            <div
-                id="${this.resultOptionId(index)}"
-                class="result-item ${index === this.selectedIndex ? "selected" : ""}"
-                data-index="${index}"
-                role="option"
-                aria-selected="${index === this.selectedIndex}"
-            >
-                <div>
-                    ${type}
-                    <div class="result-name">${this.escapeHtml(displayName)}</div>
-                    ${label}
-                    <div class="result-url">${this.escapeHtml(match.url)}</div>
-                    ${description}
-                </div>
-            </div>
-        `;
-  }
-
-  renderResults() {
-    const container = this.shadowRoot.querySelector(".results-container");
-    const input = this.shadowRoot.querySelector(".search-input");
-    const showStartContent = !input.value.trim();
-    const jumpSections = showStartContent ? this.jumpSections() : [];
-    const startBlock = showStartContent
-      ? this.jumpSectionsHtml(jumpSections)
-      : "";
-    const recentItems = showStartContent ? this.loadRecentItems() : [];
-    const defaultMatches = showStartContent ? [] : this.matches;
-    const renderedMatches = [...recentItems, ...defaultMatches];
-    this.renderedMatches = renderedMatches;
-    const emptyListbox = `<div id="${this.listboxId}" class="results-list" role="listbox" aria-label="Jump results"></div>`;
-
-    if (renderedMatches.length) {
-      if (
-        this.selectedIndex < 0 ||
-        this.selectedIndex >= renderedMatches.length
-      ) {
-        this.selectedIndex = 0;
-      }
-    } else {
-      this.selectedIndex = -1;
-    }
-
-    if (renderedMatches.length === 0) {
-      if (startBlock) {
-        container.innerHTML = startBlock + emptyListbox;
-        this.renderJumpSections(container, jumpSections);
-      } else if (showStartContent) {
-        container.innerHTML = emptyListbox;
-      } else {
-        const message = input.value.trim()
-          ? "No results found"
-          : "Start typing to search...";
-        container.innerHTML = `${emptyListbox}<div class="no-results">${message}</div>`;
-      }
-      this.updateComboboxState();
-      return;
-    }
-
-    const recentHeading = recentItems.length
-      ? `<div class="results-heading" id="${this.recentHeadingId}">Recent</div>`
-      : "";
-    const recentGroup = recentItems.length
-      ? `<div role="group" aria-labelledby="${this.recentHeadingId}">${recentItems
-          .map((match, index) => this.resultItemHtml(match, index))
-          .join("")}</div>`
-      : "";
-    const recentActions = recentItems.length
-      ? `<div class="recent-actions"><button type="button" class="clear-recent" data-clear-recent-items>Clear recent</button></div>`
-      : "";
-    const defaultHtml = defaultMatches
-      .map((match, index) =>
-        this.resultItemHtml(match, recentItems.length + index),
-      )
-      .join("");
-    container.innerHTML =
-      startBlock +
-      recentHeading +
-      `<div id="${this.listboxId}" class="results-list" role="listbox" aria-label="Jump results">${recentGroup}${defaultHtml}</div>` +
-      recentActions;
-    this.renderJumpSections(container, jumpSections);
-    this.updateComboboxState();
-
-    // Scroll selected item into view
-    if (this.selectedIndex >= 0) {
-      const selectedItem = container.querySelector(
-        `.result-item[data-index="${this.selectedIndex}"]`,
-      );
-      if (selectedItem) {
-        selectedItem.scrollIntoView({ block: "nearest" });
-      }
-    }
-  }
-
-  moveSelection(direction) {
-    const matches = this.renderedMatches || this.matches;
-    const newIndex = this.selectedIndex + direction;
-    if (newIndex >= 0 && newIndex < matches.length) {
-      this.selectedIndex = newIndex;
-      this.renderResults();
-    }
-  }
-
-  selectCurrentItem() {
-    const matches = this.renderedMatches || this.matches;
-    if (this.selectedIndex >= 0 && this.selectedIndex < matches.length) {
-      this.selectItem(this.selectedIndex);
-    }
-  }
-
-  selectItem(index) {
-    const matches = this.renderedMatches || this.matches;
-    const match = matches[index];
-    if (match) {
-      this.saveRecentItem(match);
-
-      // Dispatch custom event
-      this.dispatchEvent(
-        new CustomEvent("select", {
-          detail: match,
-          bubbles: true,
-          composed: true,
-        }),
-      );
-
-      // Navigate to URL
-      window.location.href = match.url;
-
-      this.closeMenu({ restoreFocus: false });
-    }
-  }
-
-  openMenu(trigger) {
-    const dialog = this.shadowRoot.querySelector("dialog");
-    const input = this.shadowRoot.querySelector(".search-input");
-
-    this.restoreFocusTarget = this.focusRestoreTarget(trigger);
-    this.shouldRestoreFocus = true;
-    if (!dialog.open) {
-      dialog.showModal();
-    }
-    this.setNavigationTriggersExpanded(true);
-    input.value = "";
-    input.focus();
-
-    // Reset state, then populate the default jump list.
-    this.matches = [];
-    this.selectedIndex = -1;
-    this.renderResults();
-    this.setStatus("");
-  }
-
-  closeMenu(options = {}) {
-    const dialog = this.shadowRoot.querySelector("dialog");
-    this.shouldRestoreFocus = options.restoreFocus !== false;
-    if (dialog.open) {
-      dialog.close();
-    } else {
-      this.onMenuClosed();
-    }
-  }
-
-  onMenuClosed() {
-    const input = this.shadowRoot.querySelector(".search-input");
-    this.setElementAttribute(input, "aria-expanded", "false");
-    this.removeElementAttribute(input, "aria-activedescendant");
-    this.setNavigationTriggersExpanded(false);
-    this.setStatus("");
-    if (
-      this.shouldRestoreFocus &&
-      this.restoreFocusTarget &&
-      typeof this.restoreFocusTarget.focus === "function"
-    ) {
-      this.restoreFocusTarget.focus();
-    }
-    this.restoreFocusTarget = null;
-  }
-
-  escapeHtml(text) {
-    const div = document.createElement("div");
-    div.textContent = text == null ? "" : text;
-    return div.innerHTML;
-  }
-}
-
-// Register the custom element
-customElements.define("navigation-search", NavigationSearch);

datasette/static/table.js

@@ -1,6 +1,13 @@
 var DROPDOWN_HTML = `<div class="dropdown-menu">
 <div class="hook"></div>
-<ul class="dropdown-actions"></ul>
+<ul>
+  <li><a class="dropdown-sort-asc" href="#">Sort ascending</a></li>
+  <li><a class="dropdown-sort-desc" href="#">Sort descending</a></li>
+  <li><a class="dropdown-facet" href="#">Facet by this</a></li>
+  <li><a class="dropdown-hide-column" href="#">Hide this column</a></li>
+  <li><a class="dropdown-show-all-columns" href="#">Show all columns</a></li>
+  <li><a class="dropdown-not-blank" href="#">Show not-blank rows</a></li>
+</ul>
 <p class="dropdown-column-type"></p>
 <p class="dropdown-column-description"></p>
 </div>`;
@@ -10,509 +17,54 @@ var DROPDOWN_ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="14" heig
   <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path>
 </svg>`;
 
-var SET_COLUMN_TYPE_DIALOG_ID = "set-column-type-dialog";
-var setColumnTypeDialogState = null;
-
-function getParams() {
-  return new URLSearchParams(location.search);
-}
-
-function paramsToUrl(params) {
-  var s = params.toString();
-  return s ? "?" + s : location.pathname;
-}
-
-function sortDescUrl(column) {
-  var params = getParams();
-  params.set("_sort_desc", column);
-  params.delete("_sort");
-  params.delete("_next");
-  return paramsToUrl(params);
-}
-
-function sortAscUrl(column) {
-  var params = getParams();
-  params.set("_sort", column);
-  params.delete("_sort_desc");
-  params.delete("_next");
-  return paramsToUrl(params);
-}
-
-function facetUrl(column) {
-  var params = getParams();
-  params.append("_facet", column);
-  return paramsToUrl(params);
-}
-
-function hideColumnUrl(column) {
-  var params = getParams();
-  params.append("_nocol", column);
-  return paramsToUrl(params);
-}
-
-function showAllColumnsUrl() {
-  var params = getParams();
-  params.delete("_nocol");
-  params.delete("_col");
-  return paramsToUrl(params);
-}
-
-function notBlankUrl(column) {
-  var params = getParams();
-  params.set(`${column}__notblank`, "1");
-  return paramsToUrl(params);
-}
-
-function getDisplayedFacets() {
-  return Array.from(document.querySelectorAll(".facet-info")).map(
-    (el) => el.dataset.column,
-  );
-}
-
-function getColumnClassName(th) {
-  return Array.from(th.classList).find((className) =>
-    className.startsWith("col-"),
-  );
-}
-
-function getColumnCells(th) {
-  var table = th.closest("table");
-  var columnClassName = getColumnClassName(th);
-  if (!table || !columnClassName) {
-    return [];
-  }
-  return Array.from(table.querySelectorAll("td." + columnClassName));
-}
-
-function getColumnMeta(th) {
-  return {
-    columnName: th.dataset.column,
-    columnNotNull: th.dataset.columnNotNull === "1",
-    columnType: th.dataset.columnType,
-    isPk: th.dataset.isPk === "1",
-  };
-}
-
-function getColumnTypeText(th) {
-  var columnType = th.dataset.columnType;
-  if (!columnType) {
-    return null;
-  }
-  var notNull = th.dataset.columnNotNull === "1" ? " NOT NULL" : "";
-  return `Type: ${columnType.toUpperCase()}${notNull}`;
-}
-
-function getSetColumnTypeData() {
-  return window._setColumnTypeData || null;
-}
-
-function getSetColumnTypeConfig(column) {
-  var data = getSetColumnTypeData();
-  if (!data || !data.columns) {
-    return null;
-  }
-  return data.columns[column] || null;
-}
-
-function canSetColumnType() {
-  return !!(getSetColumnTypeData() && window.HTMLDialogElement && window.fetch);
-}
-
-function setColumnTypeActionLabel(column) {
-  var columnConfig = getSetColumnTypeConfig(column);
-  if (!columnConfig) {
-    return null;
-  }
-  return columnConfig.current
-    ? `Custom type: ${columnConfig.current.type}`
-    : "Set custom type";
-}
-
-function createSetColumnTypeOption(value, name, description, checked) {
-  var label = document.createElement("label");
-  label.className = "set-column-type-option";
-
-  var input = document.createElement("input");
-  input.type = "radio";
-  input.name = "set-column-type-choice";
-  input.value = value;
-  input.checked = checked;
-
-  var content = document.createElement("span");
-  content.className = "set-column-type-option-content";
-
-  var title = document.createElement("span");
-  title.className = "set-column-type-option-name";
-  title.textContent = name;
-
-  var detail = document.createElement("span");
-  detail.className = "set-column-type-option-description";
-  detail.textContent = description;
-
-  content.appendChild(title);
-  content.appendChild(detail);
-  label.appendChild(input);
-  label.appendChild(content);
-  return label;
-}
-
-function setSetColumnTypeDialogBusy(state, isBusy) {
-  state.isBusy = isBusy;
-  state.saveButton.disabled = isBusy;
-  state.cancelButton.disabled = isBusy;
-  Array.from(
-    state.optionsWrap.querySelectorAll('input[name="set-column-type-choice"]'),
-  ).forEach(function (input) {
-    input.disabled = isBusy;
-  });
-  state.saveButton.textContent = isBusy ? "Saving..." : "Save";
-}
-
-function clearSetColumnTypeDialogError(state) {
-  state.error.hidden = true;
-  state.error.textContent = "";
-}
-
-function showSetColumnTypeDialogError(state, message) {
-  state.error.hidden = false;
-  state.error.textContent = message;
-}
-
-function ensureSetColumnTypeDialog() {
-  if (setColumnTypeDialogState) {
-    return setColumnTypeDialogState;
-  }
-  if (!window.HTMLDialogElement) {
-    return null;
-  }
-
-  var dialog = document.createElement("dialog");
-  dialog.id = SET_COLUMN_TYPE_DIALOG_ID;
-  dialog.className = "set-column-type-dialog";
-  dialog.setAttribute("aria-labelledby", "set-column-type-title");
-  dialog.innerHTML = `
-    <div class="modal-header">
-      <span class="modal-title" id="set-column-type-title">Set custom type</span>
-      <span class="modal-meta"></span>
-    </div>
-    <p class="set-column-type-status"></p>
-    <p class="set-column-type-error" hidden></p>
-    <div class="set-column-type-options"></div>
-    <div class="modal-footer">
-      <span class="footer-info"></span>
-      <button type="button" class="btn btn-ghost set-column-type-cancel">Cancel</button>
-      <button type="button" class="btn btn-primary set-column-type-save">Save</button>
-    </div>
-  `;
-  document.body.appendChild(dialog);
-
-  setColumnTypeDialogState = {
-    dialog: dialog,
-    meta: dialog.querySelector(".modal-meta"),
-    status: dialog.querySelector(".set-column-type-status"),
-    error: dialog.querySelector(".set-column-type-error"),
-    optionsWrap: dialog.querySelector(".set-column-type-options"),
-    footerInfo: dialog.querySelector(".footer-info"),
-    cancelButton: dialog.querySelector(".set-column-type-cancel"),
-    saveButton: dialog.querySelector(".set-column-type-save"),
-    currentColumn: null,
-    currentConfig: null,
-    isBusy: false,
-  };
-
-  setColumnTypeDialogState.cancelButton.addEventListener("click", function () {
-    if (!setColumnTypeDialogState.isBusy) {
-      dialog.close();
-    }
-  });
-
-  dialog.addEventListener("click", function (ev) {
-    if (ev.target === dialog && !setColumnTypeDialogState.isBusy) {
-      dialog.close();
-    }
-  });
-
-  dialog.addEventListener("cancel", function (ev) {
-    if (setColumnTypeDialogState.isBusy) {
-      ev.preventDefault();
-    }
-  });
-
-  dialog.addEventListener("close", function () {
-    clearSetColumnTypeDialogError(setColumnTypeDialogState);
-    setSetColumnTypeDialogBusy(setColumnTypeDialogState, false);
-  });
-
-  setColumnTypeDialogState.saveButton.addEventListener("click", async function () {
-    var state = setColumnTypeDialogState;
-    var selected = state.dialog.querySelector(
-      'input[name="set-column-type-choice"]:checked',
-    );
-    var selectedType = selected ? selected.value : "";
-    var currentType = state.currentConfig.current
-      ? state.currentConfig.current.type
-      : "";
-
-    if (selectedType === currentType) {
-      state.dialog.close();
-      return;
-    }
-
-    clearSetColumnTypeDialogError(state);
-    setSetColumnTypeDialogBusy(state, true);
-
-    var payload = {
-      column: state.currentColumn,
-      column_type: selectedType ? { type: selectedType } : null,
-    };
-
-    try {
-      var response = await fetch(getSetColumnTypeData().path, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          Accept: "application/json",
-        },
-        body: JSON.stringify(payload),
-      });
-      var data = await response.json();
-      if (!response.ok || data.ok === false) {
-        var message = (data.errors || ["Request failed"]).join(" ");
-        throw new Error(message);
-      }
-      location.reload();
-    } catch (error) {
-      setSetColumnTypeDialogBusy(state, false);
-      showSetColumnTypeDialogError(state, error.message || "Request failed");
-    }
-  });
-
-  return setColumnTypeDialogState;
-}
-
-function openSetColumnTypeDialog(th) {
-  var column = th.dataset.column;
-  var columnConfig = getSetColumnTypeConfig(column);
-  if (!columnConfig) {
-    return;
-  }
-
-  var state = ensureSetColumnTypeDialog();
-  if (!state) {
-    return;
-  }
-
-  clearSetColumnTypeDialogError(state);
-  setSetColumnTypeDialogBusy(state, false);
-  state.currentColumn = column;
-  state.currentConfig = columnConfig;
-  state.status.textContent = `Column: ${column}`;
-  state.meta.textContent = getColumnTypeText(th) || "Type unavailable";
-  state.footerInfo.textContent = columnConfig.current
-    ? `Current custom type: ${columnConfig.current.type}`
-    : "No custom type set.";
-  state.optionsWrap.innerHTML = "";
-
-  var currentType = columnConfig.current ? columnConfig.current.type : "";
-  state.optionsWrap.appendChild(
-    createSetColumnTypeOption(
-      "",
-      "No custom type",
-      "Use standard Datasette rendering without a custom type.",
-      currentType === "",
-    ),
-  );
-
-  columnConfig.options.forEach(function (option) {
-    state.optionsWrap.appendChild(
-      createSetColumnTypeOption(
-        option.name,
-        option.name,
-        option.description,
-        option.name === currentType,
-      ),
-    );
-  });
-
-  if (!columnConfig.options.length) {
-    var emptyState = document.createElement("p");
-    emptyState.className = "set-column-type-empty";
-    emptyState.textContent =
-      "No registered custom types are compatible with this SQLite type.";
-    state.optionsWrap.appendChild(emptyState);
-  }
-
-  if (!state.dialog.open) {
-    state.dialog.showModal();
-  }
-  var selectedOption = state.dialog.querySelector(
-    'input[name="set-column-type-choice"]:checked',
-  );
-  if (selectedOption) {
-    selectedOption.focus();
-  } else {
-    state.saveButton.focus();
-  }
-}
-
-function canChooseColumns() {
-  return !!(
-    document.querySelector("column-chooser") && window._columnChooserData
-  );
-}
-
-function shouldShowShowAllColumns() {
-  var params = getParams();
-  return params.getAll("_nocol").length || params.getAll("_col").length;
-}
-
-function hasMultipleVisibleColumns(manager) {
-  return (
-    Array.from(document.querySelectorAll(manager.selectors.tableHeaders)).filter(
-      (th) => th.dataset.column && th.dataset.isLinkColumn !== "1",
-    ).length > 1
-  );
-}
-
-function buildColumnActionItems(manager, th, options) {
-  options = options || {};
-  var params = getParams();
-  var column = th.dataset.column;
-  var columnActions = [];
-  var isSortable = !!th.querySelector("a");
-  var isFirstColumn = th.parentElement.querySelector("th:first-of-type") === th;
-  var isSinglePk =
-    th.dataset.isPk === "1" &&
-    document.querySelectorAll('th[data-is-pk="1"]').length === 1;
-  var hasBlankValues = getColumnCells(th).some(
-    (el) => el.innerText.trim() === "",
-  );
-
-  if (isSortable && params.get("_sort") !== column) {
-    columnActions.push({
-      label: "Sort ascending",
-      href: sortAscUrl(column),
-    });
-  }
-
-  if (isSortable && params.get("_sort_desc") !== column) {
-    columnActions.push({
-      label: "Sort descending",
-      href: sortDescUrl(column),
-    });
-  }
-
-  if (
-    DATASETTE_ALLOW_FACET &&
-    !isFirstColumn &&
-    !getDisplayedFacets().includes(column) &&
-    !isSinglePk
-  ) {
-    columnActions.push({
-      label: "Facet by this",
-      href: facetUrl(column),
-    });
-  }
-
-  if (options.includeChooseColumns && canChooseColumns()) {
-    columnActions.push({
-      label: "Choose columns",
-      href: "#",
-      onClick:
-        options.onChooseColumns ||
-        function (ev) {
-          ev.preventDefault();
-          openColumnChooser();
-        },
-    });
-  }
-
-  if (canSetColumnType() && getSetColumnTypeConfig(column)) {
-    columnActions.push({
-      label: setColumnTypeActionLabel(column),
-      href: "#",
-      onClick:
-        options.onSetColumnType ||
-        function (ev) {
-          ev.preventDefault();
-          window.setTimeout(function () {
-            openSetColumnTypeDialog(th);
-          }, 0);
-        },
-    });
-  }
-
-  if (th.dataset.isPk !== "1" && hasMultipleVisibleColumns(manager)) {
-    columnActions.push({
-      label: "Hide this column",
-      href: hideColumnUrl(column),
-    });
-  }
-
-  if (options.includeShowAllColumns && shouldShowShowAllColumns()) {
-    columnActions.push({
-      label: "Show all columns",
-      href: showAllColumnsUrl(),
-    });
-  }
-
-  if (params.get(`${column}__notblank`) !== "1" && hasBlankValues) {
-    columnActions.push({
-      label: "Show not-blank rows",
-      href: notBlankUrl(column),
-    });
-  }
-
-  return columnActions.concat(manager.makeColumnActions(getColumnMeta(th)));
-}
-
-function buildColumnActionState(manager, th, options) {
-  return {
-    column: th.dataset.column,
-    columnDescription: th.dataset.columnDescription || null,
-    columnMeta: getColumnMeta(th),
-    columnTypeText: getColumnTypeText(th),
-    actionItems: buildColumnActionItems(manager, th, options),
-  };
-}
-
-function initializeColumnActions(manager) {
-  manager.columnActions = {
-    buildColumnActionState: function (th, options) {
-      return buildColumnActionState(manager, th, options);
-    },
-    buildColumnActionItems: function (th, options) {
-      return buildColumnActionItems(manager, th, options);
-    },
-    canChooseColumns: canChooseColumns,
-    facetUrl: facetUrl,
-    getColumnMeta: getColumnMeta,
-    getColumnTypeText: getColumnTypeText,
-    hideColumnUrl: hideColumnUrl,
-    notBlankUrl: notBlankUrl,
-    shouldShowShowAllColumns: shouldShowShowAllColumns,
-    showAllColumnsUrl: showAllColumnsUrl,
-    sortAscUrl: sortAscUrl,
-    sortDescUrl: sortDescUrl,
-  };
-}
-
-function renderActionLink(itemConfig) {
-  var newLink = document.createElement("a");
-  newLink.textContent = itemConfig.label;
-  newLink.href = itemConfig.href || "#";
-  if (itemConfig.onClick) {
-    newLink.addEventListener("click", itemConfig.onClick);
-  }
-  return newLink;
-}
-
 /** Main initialization function for Datasette Table interactions */
 const initDatasetteTable = function (manager) {
   // Feature detection
   if (!window.URLSearchParams) {
     return;
   }
+  function getParams() {
+    return new URLSearchParams(location.search);
+  }
+  function paramsToUrl(params) {
+    var s = params.toString();
+    return s ? "?" + s : location.pathname;
+  }
+  function sortDescUrl(column) {
+    var params = getParams();
+    params.set("_sort_desc", column);
+    params.delete("_sort");
+    params.delete("_next");
+    return paramsToUrl(params);
+  }
+  function sortAscUrl(column) {
+    var params = getParams();
+    params.set("_sort", column);
+    params.delete("_sort_desc");
+    params.delete("_next");
+    return paramsToUrl(params);
+  }
+  function facetUrl(column) {
+    var params = getParams();
+    params.append("_facet", column);
+    return paramsToUrl(params);
+  }
+  function hideColumnUrl(column) {
+    var params = getParams();
+    params.append("_nocol", column);
+    return paramsToUrl(params);
+  }
+  function showAllColumnsUrl() {
+    var params = getParams();
+    params.delete("_nocol");
+    params.delete("_col");
+    return paramsToUrl(params);
+  }
+  function notBlankUrl(column) {
+    var params = getParams();
+    params.set(`${column}__notblank`, "1");
+    return paramsToUrl(params);
+  }
   function closeMenu() {
     menu.style.display = "none";
     menu.classList.remove("anim-scale-in");
@@ -544,41 +96,87 @@ const initDatasetteTable = function (manager) {
     var rect = th.getBoundingClientRect();
     var menuTop = rect.bottom + window.scrollY;
     var menuLeft = rect.left + window.scrollX;
-    var actionState = manager.columnActions.buildColumnActionState(th, {
-      includeChooseColumns: true,
-      includeShowAllColumns: true,
-      onChooseColumns: function (ev) {
-        ev.preventDefault();
-        closeMenu();
-        openColumnChooser();
-      },
-      onSetColumnType: function (ev) {
-        ev.preventDefault();
-        closeMenu();
-        window.setTimeout(function () {
-          openSetColumnTypeDialog(th);
-        }, 0);
-      },
-    });
-    var menuList = menu.querySelector("ul.dropdown-actions");
-    menuList.innerHTML = "";
-    actionState.actionItems.forEach((itemConfig) => {
-      var menuItem = document.createElement("li");
-      menuItem.appendChild(renderActionLink(itemConfig));
-      menuList.appendChild(menuItem);
-    });
-
+    var column = th.getAttribute("data-column");
+    var params = getParams();
+    var sort = menu.querySelector("a.dropdown-sort-asc");
+    var sortDesc = menu.querySelector("a.dropdown-sort-desc");
+    var facetItem = menu.querySelector("a.dropdown-facet");
+    var notBlank = menu.querySelector("a.dropdown-not-blank");
+    var hideColumn = menu.querySelector("a.dropdown-hide-column");
+    var showAllColumns = menu.querySelector("a.dropdown-show-all-columns");
+    if (params.get("_sort") == column) {
+      sort.parentNode.style.display = "none";
+    } else {
+      sort.parentNode.style.display = "block";
+      sort.setAttribute("href", sortAscUrl(column));
+    }
+    if (params.get("_sort_desc") == column) {
+      sortDesc.parentNode.style.display = "none";
+    } else {
+      sortDesc.parentNode.style.display = "block";
+      sortDesc.setAttribute("href", sortDescUrl(column));
+    }
+    /* Show hide columns options */
+    if (params.get("_nocol") || params.get("_col")) {
+      showAllColumns.parentNode.style.display = "block";
+      showAllColumns.setAttribute("href", showAllColumnsUrl());
+    } else {
+      showAllColumns.parentNode.style.display = "none";
+    }
+    if (th.getAttribute("data-is-pk") != "1") {
+      hideColumn.parentNode.style.display = "block";
+      hideColumn.setAttribute("href", hideColumnUrl(column));
+    } else {
+      hideColumn.parentNode.style.display = "none";
+    }
+    /* Only show "Facet by this" if it's not the first column, not selected,
+       not a single PK and the Datasette allow_facet setting is True */
+    var displayedFacets = Array.from(
+      document.querySelectorAll(".facet-info")
+    ).map((el) => el.dataset.column);
+    var isFirstColumn =
+      th.parentElement.querySelector("th:first-of-type") == th;
+    var isSinglePk =
+      th.getAttribute("data-is-pk") == "1" &&
+      document.querySelectorAll('th[data-is-pk="1"]').length == 1;
+    if (
+      !DATASETTE_ALLOW_FACET ||
+      isFirstColumn ||
+      displayedFacets.includes(column) ||
+      isSinglePk
+    ) {
+      facetItem.parentNode.style.display = "none";
+    } else {
+      facetItem.parentNode.style.display = "block";
+      facetItem.setAttribute("href", facetUrl(column));
+    }
+    /* Show notBlank option if not selected AND at least one visible blank value */
+    var tdsForThisColumn = Array.from(
+      th.closest("table").querySelectorAll("td." + th.className)
+    );
+    if (
+      params.get(`${column}__notblank`) != "1" &&
+      tdsForThisColumn.filter((el) => el.innerText.trim() == "").length
+    ) {
+      notBlank.parentNode.style.display = "block";
+      notBlank.setAttribute("href", notBlankUrl(column));
+    } else {
+      notBlank.parentNode.style.display = "none";
+    }
     var columnTypeP = menu.querySelector(".dropdown-column-type");
-    if (actionState.columnTypeText) {
+    var columnType = th.dataset.columnType;
+    var notNull = th.dataset.columnNotNull == 1 ? " NOT NULL" : "";
+
+    if (columnType) {
       columnTypeP.style.display = "block";
-      columnTypeP.innerText = actionState.columnTypeText;
+      columnTypeP.innerText = `Type: ${columnType.toUpperCase()}${notNull}`;
     } else {
       columnTypeP.style.display = "none";
     }
 
     var columnDescriptionP = menu.querySelector(".dropdown-column-description");
-    if (actionState.columnDescription) {
-      columnDescriptionP.innerText = actionState.columnDescription;
+    if (th.dataset.columnDescription) {
+      columnDescriptionP.innerText = th.dataset.columnDescription;
       columnDescriptionP.style.display = "block";
     } else {
       columnDescriptionP.style.display = "none";
@@ -589,6 +187,37 @@ const initDatasetteTable = function (manager) {
     menu.style.display = "block";
     menu.classList.add("anim-scale-in");
 
+    // Custom menu items on each render
+    // Plugin hook: allow adding JS-based additional menu items
+    const columnActionsPayload = {
+      columnName: th.dataset.column,
+      columnNotNull: th.dataset.columnNotNull === '1',
+      columnType: th.dataset.columnType,
+      isPk: th.dataset.isPk === '1'
+    };
+    const columnItemConfigs = manager.makeColumnActions(columnActionsPayload);
+
+    const menuList = menu.querySelector('ul');
+    columnItemConfigs.forEach(itemConfig => {
+      // Remove items from previous render. We assume entries have unique labels.
+      const existingItems = menuList.querySelectorAll(`li`);
+      Array.from(existingItems).filter(item => item.innerText === itemConfig.label).forEach(node => {
+        node.remove();
+      });
+
+      const newLink = document.createElement('a');
+      newLink.textContent = itemConfig.label;
+      newLink.href = itemConfig.href ?? '#';
+      if (itemConfig.onClick) {
+        newLink.onclick = itemConfig.onClick;
+      }
+
+      // Attach new elements to DOM
+      const menuItem = document.createElement('li');
+      menuItem.appendChild(newLink);
+      menuList.appendChild(menuItem);
+    });
+
     // Measure width of menu and adjust position if too far right
     const menuWidth = menu.offsetWidth;
     const windowWidth = window.innerWidth;
@@ -596,17 +225,17 @@ const initDatasetteTable = function (manager) {
       menu.style.left = windowWidth - menuWidth - 20 + "px";
     }
     // Align menu .hook arrow with the column cog icon
-    const hook = menu.querySelector(".hook");
-    const icon = th.querySelector(".dropdown-menu-icon");
+    const hook = menu.querySelector('.hook');
+    const icon = th.querySelector('.dropdown-menu-icon');
     const iconRect = icon.getBoundingClientRect();
-    const hookLeft = iconRect.left - menuLeft + 1 + "px";
+    const hookLeft = (iconRect.left - menuLeft + 1) + 'px';
     hook.style.left = hookLeft;
     // Move the whole menu right if the hook is too far right
     const menuRect = menu.getBoundingClientRect();
     if (iconRect.right > menuRect.right) {
-      menu.style.left = iconRect.right - menuWidth + "px";
+      menu.style.left = (iconRect.right - menuWidth) + 'px';
       // And move hook tip as well
-      hook.style.left = menuWidth - 13 + "px";
+      hook.style.left = (menuWidth - 13) + 'px';
     }
   }
 
@@ -621,9 +250,7 @@ const initDatasetteTable = function (manager) {
   menu.style.display = "none";
   document.body.appendChild(menu);
 
-  var ths = Array.from(
-    document.querySelectorAll(manager.selectors.tableHeaders),
-  );
+  var ths = Array.from(document.querySelectorAll(manager.selectors.tableHeaders));
   ths.forEach((th) => {
     if (!th.querySelector("a")) {
       return;
@@ -637,9 +264,9 @@ const initDatasetteTable = function (manager) {
 /* Add x buttons to the filter rows */
 function addButtonsToFilterRows(manager) {
   var x = "✖";
-  var rows = Array.from(
-    document.querySelectorAll(manager.selectors.filterRow),
-  ).filter((el) => el.querySelector(".filter-op"));
+  var rows = Array.from(document.querySelectorAll(manager.selectors.filterRow)).filter((el) =>
+    el.querySelector(".filter-op")
+  );
   rows.forEach((row) => {
     var a = document.createElement("a");
     a.setAttribute("href", "#");
@@ -660,18 +287,18 @@ function addButtonsToFilterRows(manager) {
       a.style.display = "none";
     }
   });
-}
+};
 
 /* Set up datalist autocomplete for filter values */
 function initAutocompleteForFilterValues(manager) {
   function createDataLists() {
     var facetResults = document.querySelectorAll(
-      manager.selectors.facetResults,
+      manager.selectors.facetResults
     );
     Array.from(facetResults).forEach(function (facetResult) {
       // Use link text from all links in the facet result
       var links = Array.from(
-        facetResult.querySelectorAll("li:not(.facet-truncated) a"),
+        facetResult.querySelectorAll("li:not(.facet-truncated) a")
       );
       // Create a datalist element
       var datalist = document.createElement("datalist");
@@ -697,57 +324,12 @@ function initAutocompleteForFilterValues(manager) {
         .setAttribute("list", "datalist-" + event.target.value);
     }
   });
-}
-
-/** Open the column-chooser web component */
-function openColumnChooser() {
-  var chooser = document.querySelector("column-chooser");
-  var data = window._columnChooserData;
-  if (!chooser || !data) return;
-
-  var nonPkColumns = data.allColumns.filter(function (col) {
-    return data.primaryKeys.indexOf(col) === -1;
-  });
-  var selected = data.selectedColumns.filter(function (col) {
-    return data.primaryKeys.indexOf(col) === -1;
-  });
-
-  chooser.open({
-    columns: nonPkColumns,
-    selected: selected,
-    onApply: function (cols) {
-      var params = new URLSearchParams(location.search);
-      params.delete("_col");
-      params.delete("_nocol");
-      params.delete("_next");
-
-      if (cols.length === nonPkColumns.length) {
-        // Check if order matches original - if so, no params needed
-        var orderMatches = cols.every(function (col, i) {
-          return col === nonPkColumns[i];
-        });
-        if (!orderMatches) {
-          cols.forEach(function (col) {
-            params.append("_col", col);
-          });
-        }
-      } else {
-        cols.forEach(function (col) {
-          params.append("_col", col);
-        });
-      }
-      var qs = params.toString();
-      location.href = qs ? "?" + qs : location.pathname;
-    },
-  });
-}
+};
 
 // Ensures Table UI is initialized only after the Manager is ready.
 document.addEventListener("datasette_init", function (evt) {
   const { detail: manager } = evt;
 
-  initializeColumnActions(manager);
-
   // Main table
   initDatasetteTable(manager);
 

datasette/stored_queries.py

@@ -1,581 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-import json
-from typing import Any, Iterable
-
-from .utils import tilde_encode, urlsafe_components
-
-UNCHANGED = object()
-
-
-QUERY_OPTION_FIELDS = (
-    "hide_sql",
-    "fragment",
-    "on_success_message",
-    "on_success_message_sql",
-    "on_success_redirect",
-    "on_error_message",
-    "on_error_redirect",
-)
-
-
-@dataclass
-class StoredQuery:
-    database: str
-    name: str
-    sql: str
-    title: str | None
-    description: str | None
-    description_html: str | None
-    hide_sql: bool
-    fragment: str | None
-    parameters: list[str]
-    is_write: bool
-    is_private: bool
-    is_trusted: bool
-    source: str
-    owner_id: str | None
-    on_success_message: str | None
-    on_success_message_sql: str | None
-    on_success_redirect: str | None
-    on_error_message: str | None
-    on_error_redirect: str | None
-    private: bool | None = None
-
-
-@dataclass
-class StoredQueryPage:
-    queries: list[StoredQuery]
-    next: str | None
-    has_more: bool
-    limit: int
-
-
-def stored_query_to_dict(query: StoredQuery) -> dict[str, Any]:
-    data = {
-        "database": query.database,
-        "name": query.name,
-        "sql": query.sql,
-        "title": query.title,
-        "description": query.description,
-        "description_html": query.description_html,
-        "hide_sql": query.hide_sql,
-        "fragment": query.fragment,
-        "params": list(query.parameters),
-        "parameters": list(query.parameters),
-        "is_write": query.is_write,
-        "is_private": query.is_private,
-        "is_trusted": query.is_trusted,
-        "source": query.source,
-        "owner_id": query.owner_id,
-        "on_success_message": query.on_success_message,
-        "on_success_message_sql": query.on_success_message_sql,
-        "on_success_redirect": query.on_success_redirect,
-        "on_error_message": query.on_error_message,
-        "on_error_redirect": query.on_error_redirect,
-    }
-    if query.private is not None:
-        data["private"] = query.private
-    return data
-
-
-def stored_query_page_to_dict(page: StoredQueryPage) -> dict[str, Any]:
-    return {
-        "queries": [stored_query_to_dict(query) for query in page.queries],
-        "next": page.next,
-        "has_more": page.has_more,
-        "limit": page.limit,
-    }
-
-
-async def save_queries_from_config(datasette: Any) -> None:
-    # Apply configured query entries from datasette.yaml to the internal table.
-    await datasette.get_internal_database().execute_write(
-        "DELETE FROM queries WHERE source = 'config'"
-    )
-    for dbname, db_config in ((datasette.config or {}).get("databases") or {}).items():
-        for query_name, query_config in (db_config.get("queries") or {}).items():
-            if not isinstance(query_config, dict):
-                query_config = {"sql": query_config}
-            await datasette.add_query(
-                dbname,
-                query_name,
-                query_config["sql"],
-                title=query_config.get("title"),
-                description=query_config.get("description"),
-                description_html=query_config.get("description_html"),
-                hide_sql=bool(query_config.get("hide_sql")),
-                fragment=query_config.get("fragment"),
-                parameters=query_config.get("params"),
-                is_write=bool(query_config.get("write")),
-                is_trusted=bool(query_config.get("is_trusted", True)),
-                source="config",
-                on_success_message=query_config.get("on_success_message"),
-                on_success_message_sql=query_config.get("on_success_message_sql"),
-                on_success_redirect=query_config.get("on_success_redirect"),
-                on_error_message=query_config.get("on_error_message"),
-                on_error_redirect=query_config.get("on_error_redirect"),
-            )
-
-
-def query_row_to_stored_query(
-    row: Any, private: bool | None = None
-) -> StoredQuery | None:
-    if row is None:
-        return None
-    parameters = json.loads(row["parameters"] or "[]")
-    options = json.loads(row["options"] or "{}")
-    return StoredQuery(
-        database=row["database_name"],
-        name=row["name"],
-        sql=row["sql"],
-        title=row["title"],
-        description=row["description"],
-        description_html=row["description_html"],
-        hide_sql=bool(options.get("hide_sql")),
-        fragment=options.get("fragment"),
-        parameters=parameters,
-        is_write=bool(row["is_write"]),
-        is_private=bool(row["is_private"]),
-        is_trusted=bool(row["is_trusted"]),
-        source=row["source"],
-        owner_id=row["owner_id"],
-        on_success_message=options.get("on_success_message"),
-        on_success_message_sql=options.get("on_success_message_sql"),
-        on_success_redirect=options.get("on_success_redirect"),
-        on_error_message=options.get("on_error_message"),
-        on_error_redirect=options.get("on_error_redirect"),
-        private=private,
-    )
-
-
-def query_options_json(options: dict[str, Any]) -> str:
-    options_dict = {}
-    for field in QUERY_OPTION_FIELDS:
-        value = options.get(field)
-        if field == "hide_sql":
-            if value:
-                options_dict[field] = True
-        elif value is not None:
-            options_dict[field] = value
-    return json.dumps(options_dict, sort_keys=True)
-
-
-async def add_query(
-    datasette: Any,
-    database: str,
-    name: str,
-    sql: str,
-    *,
-    title: str | None = None,
-    description: str | None = None,
-    description_html: str | None = None,
-    hide_sql: bool = False,
-    fragment: str | None = None,
-    parameters: Iterable[str] | None = None,
-    is_write: bool = False,
-    is_private: bool = False,
-    is_trusted: bool = False,
-    source: str = "plugin",
-    owner_id: str | None = None,
-    on_success_message: str | None = None,
-    on_success_message_sql: str | None = None,
-    on_success_redirect: str | None = None,
-    on_error_message: str | None = None,
-    on_error_redirect: str | None = None,
-    replace: bool = True,
-) -> None:
-    parameters_json = json.dumps(list(parameters or []))
-    options_json = query_options_json(
-        {
-            "hide_sql": hide_sql,
-            "fragment": fragment,
-            "on_success_message": on_success_message,
-            "on_success_message_sql": on_success_message_sql,
-            "on_success_redirect": on_success_redirect,
-            "on_error_message": on_error_message,
-            "on_error_redirect": on_error_redirect,
-        }
-    )
-    sql_statement = """
-        INSERT INTO queries (
-            database_name, name, sql, title, description, description_html,
-            options, parameters, is_write, is_private, is_trusted, source, owner_id
-        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    """
-    if replace:
-        sql_statement += """
-            ON CONFLICT(database_name, name) DO UPDATE SET
-                sql = excluded.sql,
-                title = excluded.title,
-                description = excluded.description,
-                description_html = excluded.description_html,
-                options = excluded.options,
-                parameters = excluded.parameters,
-                is_write = excluded.is_write,
-                is_private = excluded.is_private,
-                is_trusted = excluded.is_trusted,
-                source = excluded.source,
-                owner_id = excluded.owner_id,
-                updated_at = CURRENT_TIMESTAMP
-        """
-    await datasette.get_internal_database().execute_write(
-        sql_statement,
-        [
-            database,
-            name,
-            sql,
-            title,
-            description,
-            description_html,
-            options_json,
-            parameters_json,
-            int(bool(is_write)),
-            int(bool(is_private)),
-            int(bool(is_trusted)),
-            source,
-            owner_id,
-        ],
-    )
-
-
-async def update_query(
-    datasette: Any,
-    database: str,
-    name: str,
-    *,
-    sql=UNCHANGED,
-    title=UNCHANGED,
-    description=UNCHANGED,
-    description_html=UNCHANGED,
-    hide_sql=UNCHANGED,
-    fragment=UNCHANGED,
-    parameters=UNCHANGED,
-    is_write=UNCHANGED,
-    is_private=UNCHANGED,
-    is_trusted=UNCHANGED,
-    source=UNCHANGED,
-    owner_id=UNCHANGED,
-    on_success_message=UNCHANGED,
-    on_success_message_sql=UNCHANGED,
-    on_success_redirect=UNCHANGED,
-    on_error_message=UNCHANGED,
-    on_error_redirect=UNCHANGED,
-) -> None:
-    fields = {
-        "sql": sql,
-        "title": title,
-        "description": description,
-        "description_html": description_html,
-        "parameters": parameters,
-        "is_write": is_write,
-        "is_private": is_private,
-        "is_trusted": is_trusted,
-        "source": source,
-        "owner_id": owner_id,
-    }
-    option_fields = {
-        "hide_sql": hide_sql,
-        "fragment": fragment,
-        "on_success_message": on_success_message,
-        "on_success_message_sql": on_success_message_sql,
-        "on_success_redirect": on_success_redirect,
-        "on_error_message": on_error_message,
-        "on_error_redirect": on_error_redirect,
-    }
-    updates = []
-    params = []
-    for field, value in fields.items():
-        if value is UNCHANGED:
-            continue
-        if field in {"is_write", "is_private", "is_trusted"}:
-            value = int(bool(value))
-        elif field == "parameters":
-            value = json.dumps(list(value or []))
-        updates.append(f"{field} = ?")
-        params.append(value)
-    changed_options = {
-        field: value for field, value in option_fields.items() if value is not UNCHANGED
-    }
-    if changed_options:
-        rows = await datasette.get_internal_database().execute(
-            """
-            SELECT options FROM queries
-            WHERE database_name = ? AND name = ?
-            """,
-            [database, name],
-        )
-        row = rows.first()
-        options = json.loads(row["options"] or "{}") if row is not None else {}
-        for field, value in changed_options.items():
-            if field == "hide_sql":
-                if value:
-                    options[field] = True
-                else:
-                    options.pop(field, None)
-            elif value is None:
-                options.pop(field, None)
-            else:
-                options[field] = value
-        updates.append("options = ?")
-        params.append(json.dumps(options, sort_keys=True))
-    if not updates:
-        return
-    updates.append("updated_at = CURRENT_TIMESTAMP")
-    params.extend([database, name])
-    await datasette.get_internal_database().execute_write(
-        """
-        UPDATE queries
-        SET {}
-        WHERE database_name = ? AND name = ?
-        """.format(", ".join(updates)),
-        params,
-    )
-
-
-async def remove_query(
-    datasette: Any, database: str, name: str, source: str | None = None
-) -> None:
-    sql = "DELETE FROM queries WHERE database_name = ? AND name = ?"
-    params = [database, name]
-    if source is not None:
-        sql += " AND source = ?"
-        params.append(source)
-    await datasette.get_internal_database().execute_write(sql, params)
-
-
-async def get_query(datasette: Any, database: str, name: str) -> StoredQuery | None:
-    rows = await datasette.get_internal_database().execute(
-        """
-        SELECT * FROM queries
-        WHERE database_name = ? AND name = ?
-        """,
-        [database, name],
-    )
-    return query_row_to_stored_query(rows.first())
-
-
-async def count_queries(
-    datasette: Any,
-    database: str | None = None,
-    *,
-    actor: dict[str, Any] | None = None,
-    q: str | None = None,
-    is_write: bool | None = None,
-    is_private: bool | None = None,
-    is_trusted: bool | None = None,
-    source: str | None = None,
-    owner_id: str | None = None,
-) -> int:
-    allowed_sql, allowed_params = await datasette.allowed_resources_sql(
-        action="view-query",
-        actor=actor,
-        parent=database,
-    )
-    params = dict(allowed_params)
-    where_clauses = []
-    if database is not None:
-        params["query_database"] = database
-        where_clauses.append("q.database_name = :query_database")
-
-    if q:
-        where_clauses.append("""
-            (
-                q.name LIKE :query_search
-                OR q.title LIKE :query_search
-                OR q.description LIKE :query_search
-                OR q.sql LIKE :query_search
-            )
-            """)
-        params["query_search"] = "%{}%".format(q)
-    if is_write is not None:
-        where_clauses.append("q.is_write = :query_is_write")
-        params["query_is_write"] = int(bool(is_write))
-    if is_private is not None:
-        where_clauses.append("q.is_private = :query_is_private")
-        params["query_is_private"] = int(bool(is_private))
-    if is_trusted is not None:
-        where_clauses.append("q.is_trusted = :query_is_trusted")
-        params["query_is_trusted"] = int(bool(is_trusted))
-    if source is not None:
-        where_clauses.append("q.source = :query_source")
-        params["query_source"] = source
-    if owner_id is not None:
-        where_clauses.append("q.owner_id = :query_owner_id")
-        params["query_owner_id"] = owner_id
-
-    row = (
-        await datasette.get_internal_database().execute(
-            """
-            SELECT count(*) AS count
-            FROM queries q
-            JOIN (
-                {allowed_sql}
-            ) allowed
-              ON allowed.parent = q.database_name
-             AND allowed.child = q.name
-            WHERE {where}
-            """.format(
-                allowed_sql=allowed_sql,
-                where=" AND ".join(where_clauses) or "1 = 1",
-            ),
-            params,
-        )
-    ).first()
-    return row["count"]
-
-
-async def list_queries(
-    datasette: Any,
-    database: str | None = None,
-    *,
-    actor: dict[str, Any] | None = None,
-    limit: int = 50,
-    cursor: str | None = None,
-    q: str | None = None,
-    is_write: bool | None = None,
-    is_private: bool | None = None,
-    is_trusted: bool | None = None,
-    source: str | None = None,
-    owner_id: str | None = None,
-    include_private: bool = False,
-) -> StoredQueryPage:
-    limit = min(max(1, int(limit)), 1000)
-    allowed_sql, allowed_params = await datasette.allowed_resources_sql(
-        action="view-query",
-        actor=actor,
-        parent=database,
-        include_is_private=include_private,
-    )
-    params = dict(allowed_params)
-    params.update({"limit": limit + 1})
-    sort_key_sql = "lower(coalesce(nullif(q.title, ''), q.name))"
-    where_clauses = []
-    order_by = "q.database_name, sort_key, q.name"
-    if database is not None:
-        params["query_database"] = database
-        where_clauses.append("q.database_name = :query_database")
-        order_by = "sort_key, q.name"
-
-    if cursor:
-        try:
-            components = urlsafe_components(cursor)
-        except ValueError:
-            components = []
-        if database is None and len(components) == 3:
-            where_clauses.append("""
-                (
-                    q.database_name > :cursor_database
-                    OR (
-                        q.database_name = :cursor_database
-                        AND (
-                            {sort_key_sql} > :cursor_sort_key
-                            OR (
-                                {sort_key_sql} = :cursor_sort_key
-                                AND q.name > :cursor_name
-                            )
-                        )
-                    )
-                )
-                """.format(sort_key_sql=sort_key_sql))
-            params["cursor_database"] = components[0]
-            params["cursor_sort_key"] = components[1]
-            params["cursor_name"] = components[2]
-        elif database is not None and len(components) == 2:
-            where_clauses.append("""
-                (
-                    {sort_key_sql} > :cursor_sort_key
-                    OR (
-                        {sort_key_sql} = :cursor_sort_key
-                        AND q.name > :cursor_name
-                    )
-                )
-                """.format(sort_key_sql=sort_key_sql))
-            params["cursor_sort_key"] = components[0]
-            params["cursor_name"] = components[1]
-
-    if q:
-        where_clauses.append("""
-            (
-                q.name LIKE :query_search
-                OR q.title LIKE :query_search
-                OR q.description LIKE :query_search
-                OR q.sql LIKE :query_search
-            )
-            """)
-        params["query_search"] = "%{}%".format(q)
-    if is_write is not None:
-        where_clauses.append("q.is_write = :query_is_write")
-        params["query_is_write"] = int(bool(is_write))
-    if is_private is not None:
-        where_clauses.append("q.is_private = :query_is_private")
-        params["query_is_private"] = int(bool(is_private))
-    if is_trusted is not None:
-        where_clauses.append("q.is_trusted = :query_is_trusted")
-        params["query_is_trusted"] = int(bool(is_trusted))
-    if source is not None:
-        where_clauses.append("q.source = :query_source")
-        params["query_source"] = source
-    if owner_id is not None:
-        where_clauses.append("q.owner_id = :query_owner_id")
-        params["query_owner_id"] = owner_id
-
-    private_select = ", allowed.is_private AS private" if include_private else ""
-    rows = list(
-        (
-            await datasette.get_internal_database().execute(
-                """
-                SELECT q.*, {sort_key_sql} AS sort_key{private_select}
-                FROM queries q
-                JOIN (
-                    {allowed_sql}
-                ) allowed
-                  ON allowed.parent = q.database_name
-                 AND allowed.child = q.name
-                WHERE {where}
-                ORDER BY {order_by}
-                LIMIT :limit
-                """.format(
-                    allowed_sql=allowed_sql,
-                    private_select=private_select,
-                    sort_key_sql=sort_key_sql,
-                    where=" AND ".join(where_clauses) or "1 = 1",
-                    order_by=order_by,
-                ),
-                params,
-            )
-        ).rows
-    )
-    has_more = len(rows) > limit
-    if has_more:
-        rows = rows[:limit]
-
-    queries = []
-    for row in rows:
-        query = query_row_to_stored_query(
-            row, private=bool(row["private"]) if include_private else None
-        )
-        assert query is not None
-        queries.append(query)
-
-    next_token = None
-    if has_more and rows:
-        last_row = rows[-1]
-        if database is None:
-            next_token = "{},{},{}".format(
-                tilde_encode(last_row["database_name"]),
-                tilde_encode(last_row["sort_key"]),
-                tilde_encode(last_row["name"]),
-            )
-        else:
-            next_token = "{},{}".format(
-                tilde_encode(last_row["sort_key"]),
-                tilde_encode(last_row["name"]),
-            )
-    return StoredQueryPage(
-        queries=queries,
-        next=next_token,
-        has_more=has_more,
-        limit=limit,
-    )

datasette/templates/_action_menu.html

@@ -1,7 +1,7 @@
 {% if action_links %}
 <div class="page-action-menu">
 <details class="actions-menu-links details-menu">
-    <summary aria-haspopup="menu" aria-expanded="false">
+    <summary>
         <div class="icon-text">
             <svg class="icon" aria-labelledby="actions-menu-links-title" role="img" style="color: #fff" xmlns="http://www.w3.org/2000/svg" width="28" height="28" viewBox="0 0 28 28" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
                 <title id="actions-menu-links-title">{{ action_title }}</title>
@@ -13,9 +13,9 @@
     </summary>
     <div class="dropdown-menu">
         <div class="hook"></div>
-        <ul role="menu">
+        <ul>
             {% for link in action_links %}
-            <li role="none"><a href="{{ link.href }}" role="menuitem" tabindex="-1">{{ link.label }}
+            <li><a href="{{ link.href }}">{{ link.label }}
             {% if link.description %}
                 <p class="dropdown-description">{{ link.description }}</p>
             {% endif %}</a>

datasette/templates/_close_open_menus.html

@@ -13,50 +13,4 @@ document.body.addEventListener('click', (ev) => {
         (details) => details.open && details != detailsClickedWithin
     ).forEach(details => details.open = false);
 });
-
-/* Sync aria-expanded and add keyboard navigation for details-menu elements */
-document.querySelectorAll('details.details-menu').forEach(function(details) {
-    var summary = details.querySelector('summary');
-    details.addEventListener('toggle', function() {
-        if (summary) {
-            summary.setAttribute('aria-expanded', details.open ? 'true' : 'false');
-        }
-        if (details.open) {
-            /* Focus first menu item when menu opens */
-            var firstItem = details.querySelector('[role="menuitem"]');
-            if (firstItem) { firstItem.focus(); }
-        }
-    });
-});
-
-document.body.addEventListener('keydown', function(ev) {
-    /* Keyboard navigation for open details-menu elements */
-    var openDetails = Array.from(document.querySelectorAll('details.details-menu[open]'));
-    if (!openDetails.length) { return; }
-
-    if (ev.key === 'Escape') {
-        openDetails.forEach(function(details) {
-            details.open = false;
-            var summary = details.querySelector('summary');
-            if (summary) { summary.focus(); }
-        });
-        return;
-    }
-
-    if (ev.key === 'ArrowDown' || ev.key === 'ArrowUp') {
-        var focused = document.activeElement;
-        openDetails.forEach(function(details) {
-            var items = Array.from(details.querySelectorAll('[role="menuitem"]'));
-            if (!items.length) { return; }
-            var idx = items.indexOf(focused);
-            if (idx === -1) { return; }
-            ev.preventDefault();
-            if (ev.key === 'ArrowDown') {
-                items[(idx + 1) % items.length].focus();
-            } else {
-                items[(idx - 1 + items.length) % items.length].focus();
-            }
-        });
-    }
-});
 </script>

datasette/templates/_debug_common_functions.html

@@ -1,50 +0,0 @@
-<script>
-// Common utility functions for debug pages
-
-// Populate form from URL parameters on page load
-function populateFormFromURL() {
-    const params = new URLSearchParams(window.location.search);
-
-    const action = params.get('action');
-    if (action) {
-        const actionField = document.getElementById('action');
-        if (actionField) {
-            actionField.value = action;
-        }
-    }
-
-    const parent = params.get('parent');
-    if (parent) {
-        const parentField = document.getElementById('parent');
-        if (parentField) {
-            parentField.value = parent;
-        }
-    }
-
-    const child = params.get('child');
-    if (child) {
-        const childField = document.getElementById('child');
-        if (childField) {
-            childField.value = child;
-        }
-    }
-
-    const pageSize = params.get('page_size');
-    if (pageSize) {
-        const pageSizeField = document.getElementById('page_size');
-        if (pageSizeField) {
-            pageSizeField.value = pageSize;
-        }
-    }
-
-    return params;
-}
-
-// HTML escape function
-function escapeHtml(text) {
-    if (text === null || text === undefined) return '';
-    const div = document.createElement('div');
-    div.textContent = text;
-    return div.innerHTML;
-}
-</script>

datasette/templates/_execute_write_analysis_scripts.html

@@ -1,111 +0,0 @@
-<script>
-window.datasetteSqlAnalysis = (() => {
-  if (
-    window.datasetteSqlAnalysis &&
-    window.datasetteSqlAnalysis.renderAnalysis
-  ) {
-    return window.datasetteSqlAnalysis;
-  }
-
-  function appendCodeCell(row, value, emptyText) {
-    const cell = document.createElement("td");
-    if (value) {
-      const code = document.createElement("code");
-      code.textContent = value;
-      cell.appendChild(code);
-    } else if (emptyText) {
-      appendNotApplicable(cell);
-    }
-    row.appendChild(cell);
-  }
-
-  function appendNotApplicable(cell) {
-    const notApplicable = document.createElement("span");
-    notApplicable.className = "execute-write-analysis-na";
-    notApplicable.textContent = "n/a";
-    cell.appendChild(notApplicable);
-  }
-
-  function renderAnalysis(section, data) {
-    if (!section) {
-      return;
-    }
-    section.replaceChildren();
-    if (data.has_sql === false) {
-      section.hidden = true;
-      return;
-    }
-    section.hidden = false;
-
-    const heading = document.createElement("h2");
-    heading.textContent = "Query operations";
-    section.appendChild(heading);
-
-    if (data.analysis_error) {
-      const error = document.createElement("p");
-      error.className = "message-error";
-      error.textContent = data.analysis_error;
-      section.appendChild(error);
-      return;
-    }
-
-    const rows = data.analysis_rows || [];
-    if (!rows.length) {
-      const empty = document.createElement("p");
-      empty.textContent =
-        "Analysis will show each affected table and required permission.";
-      section.appendChild(empty);
-      return;
-    }
-
-    const wrapper = document.createElement("div");
-    wrapper.className = "table-wrapper";
-    const table = document.createElement("table");
-    table.className = "execute-write-analysis";
-    const thead = document.createElement("thead");
-    const headerRow = document.createElement("tr");
-    [
-      "Operation",
-      "Database",
-      "Table",
-      "Required permission",
-      "Allowed",
-    ].forEach((label) => {
-      const th = document.createElement("th");
-      th.scope = "col";
-      th.textContent = label;
-      headerRow.appendChild(th);
-    });
-    thead.appendChild(headerRow);
-    table.appendChild(thead);
-
-    const tbody = document.createElement("tbody");
-    rows.forEach((analysisRow) => {
-      const row = document.createElement("tr");
-      appendCodeCell(row, analysisRow.operation);
-      appendCodeCell(row, analysisRow.database);
-      appendCodeCell(row, analysisRow.table);
-      appendCodeCell(row, analysisRow.required_permission, "n/a");
-
-      const allowedCell = document.createElement("td");
-      if (analysisRow.allowed !== null && analysisRow.allowed !== undefined) {
-        const allowed = document.createElement("span");
-        allowed.className = analysisRow.allowed
-          ? "execute-write-analysis-allowed"
-          : "execute-write-analysis-denied";
-        allowed.textContent = analysisRow.allowed ? "yes" : "no";
-        allowedCell.appendChild(allowed);
-      } else {
-        appendNotApplicable(allowedCell);
-      }
-      row.appendChild(allowedCell);
-      tbody.appendChild(row);
-    });
-    table.appendChild(tbody);
-    wrapper.appendChild(table);
-    section.appendChild(wrapper);
-  }
-
-  return { renderAnalysis };
-})();
-</script>

datasette/templates/_execute_write_analysis_styles.html

@@ -1,41 +0,0 @@
-<style>
-.execute-write-analysis {
-    border-collapse: collapse;
-    font-size: 0.9rem;
-    margin: 0.25rem 0 1rem;
-    min-width: 44rem;
-}
-.execute-write-analysis th,
-.execute-write-analysis td {
-    border-bottom: 1px solid #d7dde5;
-    padding: 0.45rem 0.7rem;
-    text-align: left;
-    vertical-align: top;
-}
-.execute-write-analysis th {
-    background-color: #edf6fb;
-    border-top: 1px solid #d7dde5;
-    color: #39445a;
-    font-weight: 700;
-}
-.execute-write-analysis tbody tr:nth-child(even) {
-    background-color: rgba(39, 104, 144, 0.05);
-}
-.execute-write-analysis code {
-    background: transparent;
-    font-size: 0.9em;
-    white-space: nowrap;
-}
-.execute-write-analysis-allowed {
-    color: #267a3e;
-    font-weight: 700;
-}
-.execute-write-analysis-denied {
-    color: #b00020;
-    font-weight: 700;
-}
-.execute-write-analysis-na {
-    color: #687386;
-    font-style: italic;
-}
-</style>

datasette/templates/_permissions_debug_tabs.html

@@ -1,54 +0,0 @@
-{% if has_debug_permission %}
-{% set query_string = '?' + request.query_string if request.query_string else '' %}
-
-<style>
-.permissions-debug-tabs {
-    border-bottom: 2px solid #e0e0e0;
-    margin-bottom: 2em;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.5em;
-}
-.permissions-debug-tabs a {
-    padding: 0.75em 1.25em;
-    text-decoration: none;
-    color: #333;
-    border-bottom: 3px solid transparent;
-    margin-bottom: -2px;
-    transition: all 0.2s;
-    font-weight: 500;
-}
-.permissions-debug-tabs a:hover {
-    background-color: #f5f5f5;
-    border-bottom-color: #999;
-}
-.permissions-debug-tabs a.active {
-    color: #0066cc;
-    border-bottom-color: #0066cc;
-    background-color: #f0f7ff;
-}
-@media only screen and (max-width: 576px) {
-    .permissions-debug-tabs {
-        flex-direction: column;
-        gap: 0;
-    }
-    .permissions-debug-tabs a {
-        border-bottom: 1px solid #e0e0e0;
-        margin-bottom: 0;
-    }
-    .permissions-debug-tabs a.active {
-        border-left: 3px solid #0066cc;
-        border-bottom: 1px solid #e0e0e0;
-    }
-}
-</style>
-
-<nav class="permissions-debug-tabs">
-    <a href="{{ urls.path('-/permissions') }}" {% if current_tab == "permissions" %}class="active"{% endif %}>Playground</a>
-    <a href="{{ urls.path('-/check') }}{{ query_string }}" {% if current_tab == "check" %}class="active"{% endif %}>Check</a>
-    <a href="{{ urls.path('-/allowed') }}{{ query_string }}" {% if current_tab == "allowed" %}class="active"{% endif %}>Allowed</a>
-    <a href="{{ urls.path('-/rules') }}{{ query_string }}" {% if current_tab == "rules" %}class="active"{% endif %}>Rules</a>
-    <a href="{{ urls.path('-/actions') }}" {% if current_tab == "actions" %}class="active"{% endif %}>Actions</a>
-    <a href="{{ urls.path('-/allow-debug') }}" {% if current_tab == "allow_debug" %}class="active"{% endif %}>Allow debug</a>
-</nav>
-{% endif %}

datasette/templates/_sql_parameter_scripts.html

@@ -1,293 +0,0 @@
-<script>
-window.datasetteSqlParameters = (() => {
-  if (
-    window.datasetteSqlParameters &&
-    window.datasetteSqlParameters.setupSqlParameterRefresh
-  ) {
-    return window.datasetteSqlParameters;
-  }
-
-  function currentSql(form) {
-    if (window.editor) {
-      return window.editor.state.doc.toString();
-    }
-    const sqlInput = form.querySelector("textarea#sql-editor, input[name=sql]");
-    return sqlInput ? sqlInput.value : "";
-  }
-
-  function controlState(control) {
-    return {
-      value: control.value,
-      expanded: control.tagName.toLowerCase() === "textarea",
-    };
-  }
-
-  function syncParameterState(manager) {
-    manager.parameterState = new Map();
-    manager.section
-      .querySelectorAll("[data-parameter-control]")
-      .forEach((control) => {
-        manager.parameterState.set(control.name, controlState(control));
-      });
-  }
-
-  function createControl(parameter, id, state) {
-    const control = document.createElement(state.expanded ? "textarea" : "input");
-    control.id = id;
-    control.name = parameter;
-    control.value = state.value;
-    control.setAttribute("data-parameter-control", "");
-    if (state.expanded) {
-      control.rows = 5;
-    } else {
-      control.type = "text";
-    }
-    return control;
-  }
-
-  function replaceParameterControl(
-    manager,
-    control,
-    button,
-    expand,
-    value,
-    selectionStart
-  ) {
-    const replacement = createControl(control.name, control.id, {
-      value: value === undefined ? control.value : value,
-      expanded: expand,
-    });
-    button.textContent = expand ? "Collapse" : "Expand";
-    button.setAttribute("aria-expanded", expand ? "true" : "false");
-    control.replaceWith(replacement);
-    replacement.focus();
-    if (selectionStart !== undefined && replacement.setSelectionRange) {
-      replacement.setSelectionRange(selectionStart, selectionStart);
-    }
-    manager.parameterState.set(replacement.name, controlState(replacement));
-  }
-
-  function renderParameters(manager, parameters) {
-    syncParameterState(manager);
-    const previousState = manager.parameterState;
-    const nextState = new Map();
-    manager.section.replaceChildren();
-    if (!parameters.length) {
-      manager.parameterState = nextState;
-      return;
-    }
-
-    const heading = document.createElement("h2");
-    heading.textContent = "Parameters";
-    manager.section.appendChild(heading);
-
-    parameters.forEach((parameter, index) => {
-      const id = `qp${index + 1}`;
-      const state = previousState.get(parameter) || {
-        value: "",
-        expanded: false,
-      };
-      if (!manager.allowExpand) {
-        state.expanded = false;
-      }
-      nextState.set(parameter, state);
-
-      const row = document.createElement("p");
-      row.className = "sql-parameter-row";
-
-      const label = document.createElement("label");
-      label.htmlFor = id;
-      label.textContent = parameter;
-
-      const control = createControl(parameter, id, state);
-
-      row.append(label, control);
-      if (manager.allowExpand) {
-        const button = document.createElement("button");
-        button.type = "button";
-        button.className = "sql-parameter-toggle";
-        button.setAttribute("data-parameter-toggle", "");
-        button.setAttribute("aria-controls", id);
-        button.setAttribute("aria-expanded", state.expanded ? "true" : "false");
-        button.textContent = state.expanded ? "Collapse" : "Expand";
-        row.append(" ", button);
-      }
-      manager.section.appendChild(row);
-    });
-
-    manager.parameterState = nextState;
-  }
-
-  function bindParameterControls(manager) {
-    manager.form.addEventListener("input", (event) => {
-      const control = event.target;
-      if (!control.matches || !control.matches("[data-parameter-control]")) {
-        return;
-      }
-      manager.parameterState.set(control.name, controlState(control));
-    });
-
-    if (!manager.allowExpand) {
-      return;
-    }
-
-    manager.form.addEventListener("click", (event) => {
-      const button = event.target.closest
-        ? event.target.closest("[data-parameter-toggle]")
-        : null;
-      if (!button || !manager.form.contains(button)) {
-        return;
-      }
-      const control = document.getElementById(button.getAttribute("aria-controls"));
-      if (!control) {
-        return;
-      }
-      const expanded = control.tagName.toLowerCase() === "textarea";
-      replaceParameterControl(manager, control, button, !expanded);
-    });
-
-    manager.form.addEventListener("paste", (event) => {
-      const control = event.target;
-      if (
-        !(control instanceof HTMLInputElement) ||
-        !control.matches("[data-parameter-control]")
-      ) {
-        return;
-      }
-      const pasted = event.clipboardData ? event.clipboardData.getData("text") : "";
-      if (!/[\r\n]/.test(pasted)) {
-        return;
-      }
-      const button = document.querySelector(
-        `[data-parameter-toggle][aria-controls="${control.id}"]`
-      );
-      if (!button) {
-        return;
-      }
-      event.preventDefault();
-      const selectionStart = control.selectionStart ?? control.value.length;
-      const selectionEnd = control.selectionEnd ?? selectionStart;
-      const value =
-        control.value.slice(0, selectionStart) +
-        pasted +
-        control.value.slice(selectionEnd);
-      replaceParameterControl(
-        manager,
-        control,
-        button,
-        true,
-        value,
-        selectionStart + pasted.length
-      );
-    });
-  }
-
-  function bindEditorChanges(form, callback) {
-    const editorElement = form.querySelector(".cm-content");
-    if (editorElement) {
-      editorElement.addEventListener("input", callback);
-    }
-    if (!window.editor) {
-      const sqlInput = form.querySelector("textarea#sql-editor");
-      if (sqlInput) {
-        sqlInput.addEventListener("input", callback);
-      }
-      return;
-    }
-    if (!window.editor.datasetteSqlParameterCallbacks) {
-      const editor = window.editor;
-      const originalDispatch = editor.dispatch.bind(editor);
-      editor.datasetteSqlParameterCallbacks = [];
-      editor.dispatch = (...transactions) => {
-        const before = editor.state.doc.toString();
-        originalDispatch(...transactions);
-        if (editor.state.doc.toString() !== before) {
-          editor.datasetteSqlParameterCallbacks.forEach((listener) => listener());
-        }
-      };
-    }
-    window.editor.datasetteSqlParameterCallbacks.push(callback);
-  }
-
-  function setupSqlParameterRefresh(options) {
-    const form =
-      options.form || document.querySelector("form.sql.core[data-parameters-url]");
-    if (!form) {
-      return null;
-    }
-    const shouldRenderParameters = options.renderParameters !== false;
-    const section =
-      options.section || form.querySelector("[data-sql-parameters-section]");
-    if (shouldRenderParameters && !section) {
-      return null;
-    }
-    const manager = {
-      form,
-      section,
-      allowExpand:
-        options.allowExpand === undefined
-          ? section
-            ? section.dataset.allowExpand === "1"
-            : false
-          : options.allowExpand,
-      parameterState: new Map(),
-    };
-    if (section) {
-      bindParameterControls(manager);
-      syncParameterState(manager);
-    }
-
-    const url = options.url || form.dataset.parametersUrl;
-    let refreshTimer = null;
-    let refreshSequence = 0;
-
-    async function refreshParameters() {
-      if (!url) {
-        return;
-      }
-      const sequence = ++refreshSequence;
-      try {
-        const requestUrl = new URL(url, window.location.href);
-        requestUrl.searchParams.set("sql", currentSql(form));
-        const response = await fetch(requestUrl, {
-          headers: { accept: "application/json" },
-        });
-        const data = await response.json();
-        if (sequence !== refreshSequence) {
-          return;
-        }
-        if (!response.ok) {
-          throw new Error((data.errors || [response.statusText]).join("; "));
-        }
-        if (shouldRenderParameters) {
-          renderParameters(manager, data.parameters || []);
-        }
-        if (options.onData) {
-          options.onData(data, manager);
-        }
-      } catch (error) {
-        if (sequence !== refreshSequence) {
-          return;
-        }
-        if (options.onError) {
-          options.onError(error, manager);
-        }
-      }
-    }
-
-    function scheduleRefresh() {
-      clearTimeout(refreshTimer);
-      refreshTimer = setTimeout(refreshParameters, options.debounceMs || 350);
-    }
-
-    bindEditorChanges(form, scheduleRefresh);
-    return {
-      currentSql: () => currentSql(form),
-      refreshParameters,
-      renderParameters: (parameters) => renderParameters(manager, parameters),
-    };
-  }
-
-  return { setupSqlParameterRefresh };
-})();
-</script>

datasette/templates/_sql_parameter_styles.html

@@ -1,58 +0,0 @@
-<style>
-form.sql .sql-editor {
-    max-width: 52rem;
-}
-form.sql .sql-editor textarea#sql-editor {
-    width: 100%;
-}
-form.sql .sql-parameters-section {
-    max-width: 52rem;
-}
-form.sql .sql-parameter-row {
-    align-items: start;
-    column-gap: 0.6rem;
-    display: grid;
-    grid-template-columns: minmax(8rem, 11rem) minmax(16rem, 1fr) auto;
-    margin: 0 0 0.65rem;
-    max-width: 52rem;
-}
-form.sql .sql-parameter-row label {
-    overflow-wrap: anywhere;
-    padding-top: 0.55rem;
-    width: auto;
-}
-form.sql .sql-parameter-row input[data-parameter-control],
-form.sql .sql-parameter-row textarea[data-parameter-control] {
-    box-sizing: border-box;
-    width: 100%;
-}
-form.sql .sql-parameter-row textarea[data-parameter-control] {
-    border: 1px solid #ccc;
-    border-radius: 3px;
-    display: block;
-    font-family: Helvetica, sans-serif;
-    font-size: 1em;
-    min-height: 7rem;
-    padding: 9px 4px;
-}
-form.sql.core button.sql-parameter-toggle[type=button] {
-    font-size: 0.72rem;
-    height: 1.8rem;
-    line-height: 1;
-    margin: 0.25rem 0 0;
-    padding: 0.25rem 0.45rem;
-}
-@media (max-width: 480px) {
-    form.sql .sql-parameter-row {
-        grid-template-columns: 1fr;
-        row-gap: 0.25rem;
-    }
-    form.sql .sql-parameter-row label {
-        padding-top: 0;
-    }
-    form.sql.core button.sql-parameter-toggle[type=button] {
-        justify-self: start;
-        margin-top: 0;
-    }
-}
-</style>

datasette/templates/_sql_parameters.html

@@ -1,9 +0,0 @@
-<div id="{{ sql_parameters_section_id|default("sql-parameters-section") }}" class="sql-parameters-section" data-sql-parameters-section{% if sql_parameters_allow_expand|default(false) %} data-allow-expand="1"{% endif %}>
-    {% if parameter_names %}
-        <h2>Parameters</h2>
-        {% for parameter in parameter_names %}
-            {% set parameter_id = (sql_parameter_id_prefix|default("qp")) ~ loop.index %}
-            <p class="sql-parameter-row"><label for="{{ parameter_id }}">{{ parameter }}</label> <input type="text" id="{{ parameter_id }}" name="{{ parameter }}" value="{{ parameter_values.get(parameter, "") }}" data-parameter-control>{% if sql_parameters_allow_expand|default(false) %} <button type="button" class="sql-parameter-toggle" data-parameter-toggle aria-controls="{{ parameter_id }}" aria-expanded="false">Expand</button>{% endif %}</p>
-        {% endfor %}
-    {% endif %}
-</div>

datasette/templates/_table.html

@@ -1,12 +1,12 @@
 <!-- above-table-panel is a hook node for plugins to attach to . Displays even if no data available -->
 <div class="above-table-panel"> </div>
-{% if display_columns %}
+{% if display_rows %}
 <div class="table-wrapper">
     <table class="rows-and-columns">
         <thead>
             <tr>
                 {% for column in display_columns %}
-                    <th {% if column.description %}data-column-description="{{ column.description }}" {% endif %}class="col-{{ column.name|to_css_class }}" scope="col" data-column="{{ column.name }}" data-column-type="{{ column.type.lower() }}" data-column-not-null="{{ column.notnull }}" data-is-pk="{% if column.is_pk %}1{% else %}0{% endif %}"{% if column.is_special_link_column %} data-is-link-column="1"{% endif %}>
+                    <th {% if column.description %}data-column-description="{{ column.description }}" {% endif %}class="col-{{ column.name|to_css_class }}" scope="col" data-column="{{ column.name }}" data-column-type="{{ column.type.lower() }}" data-column-not-null="{{ column.notnull }}" data-is-pk="{% if column.is_pk %}1{% else %}0{% endif %}">
                         {% if not column.sortable %}
                             {{ column.name }}
                         {% else %}
@@ -31,7 +31,6 @@
         </tbody>
     </table>
 </div>
-{% endif %}
-{% if not display_rows %}
+{% else %}
     <p class="zero-results">0 records</p>
 {% endif %}

datasette/templates/allow_debug.html

@@ -33,9 +33,6 @@ p.message-warning {
 
 <h1>Debug allow rules</h1>
 
-{% set current_tab = "allow_debug" %}
-{% include "_permissions_debug_tabs.html" %}
-
 <p>Use this tool to try out different actor and allow combinations. See <a href="https://docs.datasette.io/en/stable/authentication.html#defining-permissions-with-allow-blocks">Defining permissions with "allow" blocks</a> for documentation.</p>
 
 <form class="core" action="{{ urls.path('-/allow-debug') }}" method="get" style="margin-bottom: 1em">

datasette/templates/base.html

@@ -20,7 +20,7 @@
 <body class="{% block body_class %}{% endblock %}">
 <div class="not-footer">
 <header class="hd"><nav>{% block nav %}{% block crumbs %}{{ crumbs.nav(request=request) }}{% endblock %}
-    {% set links = menu_links() %}
+    {% set links = menu_links() %}{% if links or show_logout %}
     <details class="nav-menu details-menu">
         <summary><svg aria-labelledby="nav-menu-svg-title" role="img"
             fill="currentColor" stroke="currentColor" xmlns="http://www.w3.org/2000/svg"
@@ -29,18 +29,20 @@
                 <path fill-rule="evenodd" d="M1 2.75A.75.75 0 011.75 2h12.5a.75.75 0 110 1.5H1.75A.75.75 0 011 2.75zm0 5A.75.75 0 011.75 7h12.5a.75.75 0 110 1.5H1.75A.75.75 0 011 7.75zM1.75 12a.75.75 0 100 1.5h12.5a.75.75 0 100-1.5H1.75z"></path>
         </svg></summary>
         <div class="nav-menu-inner">
+            {% if links %}
             <ul>
-                <li><button type="button" class="button-as-link" data-navigation-search-open aria-haspopup="dialog" aria-expanded="false" aria-keyshortcuts="/">Jump to... <kbd class="keyboard-shortcut" aria-hidden="true" title="Keyboard shortcut: press / to open Jump to">/</kbd></button></li>
                 {% for link in links %}
                 <li><a href="{{ link.href }}">{{ link.label }}</a></li>
                 {% endfor %}
             </ul>
+            {% endif %}
             {% if show_logout %}
             <form class="nav-menu-logout" action="{{ urls.logout() }}" method="post">
+                <input type="hidden" name="csrftoken" value="{{ csrftoken() }}">
                 <button class="button-as-link">Log out</button>
             </form>{% endif %}
         </div>
-    </details>
+    </details>{% endif %}
     {% if actor %}
     <div class="actor">
         <strong>{{ display_actor(actor) }}</strong>
@@ -70,7 +72,5 @@
 {% endfor %}
 
 {% if select_templates %}<!-- Templates considered: {{ select_templates|join(", ") }} -->{% endif %}
-<script src="{{ urls.static('navigation-search.js') }}" defer></script>
-<navigation-search url="/-/jump"></navigation-search>
 </body>
 </html>

datasette/templates/create_token.html

@@ -50,13 +50,14 @@
       </select>
     </div>
     <input type="text" name="expire_duration" style="width: 10%">
+    <input type="hidden" name="csrftoken" value="{{ csrftoken() }}">
     <input type="submit" value="Create token">
 
   <details style="margin-top: 1em" id="restrict-permissions">
     <summary style="cursor: pointer;">Restrict actions that can be performed using this token</summary>
     <h2>All databases and tables</h2>
     <ul>
-      {% for permission in all_actions %}
+      {% for permission in all_permissions %}
         <li><label><input type="checkbox" name="all:{{ permission }}"> {{ permission }}</label></li>
       {% endfor %}
     </ul>
@@ -64,7 +65,7 @@
     {% for database in database_with_tables %}
       <h2>All tables in "{{ database.name }}"</h2>
       <ul>
-        {% for permission in database_actions %}
+        {% for permission in database_permissions %}
           <li><label><input type="checkbox" name="database:{{ database.encoded }}:{{ permission }}"> {{ permission }}</label></li>
         {% endfor %}
       </ul>
@@ -74,7 +75,7 @@
       {% for table in database.tables %}
         <h3>{{ database.name }}: {{ table.name }}</h3>
         <ul>
-          {% for permission in child_actions %}
+          {% for permission in resource_permissions %}
             <li><label><input type="checkbox" name="resource:{{ database.encoded }}:{{ table.encoded }}:{{ permission }}"> {{ permission }}</label></li>
           {% endfor %}
         </ul>

datasette/templates/csrf_error.html

@@ -1,5 +1,5 @@
 {% extends "base.html" %}
-{% block title %}CSRF check failed{% endblock %}
+{% block title %}CSRF check failed){% endblock %}
 {% block content %}
 <h1>Form origin check failed</h1>
 
@@ -7,7 +7,7 @@
 
 <details><summary>Technical details</summary>
   <p>Developers: consult Datasette's <a href="https://docs.datasette.io/en/latest/internals.html#csrf-protection">CSRF protection documentation</a>.</p>
-  <p>Reason: {{ reason }}</p>
+  <p>Error code is {{ message_name }}.</p>
 </details>
 
 {% endblock %}

datasette/templates/database.html

@@ -5,7 +5,6 @@
 {% block extra_head %}
 {{- super() -}}
 {% include "_codemirror.html" %}
-{% include "_sql_parameter_styles.html" %}
 {% endblock %}
 
 {% block body_class %}db db-{{ database|to_css_class }}{% endblock %}
@@ -26,13 +25,9 @@
 {% block description_source_license %}{% include "_description_source_license.html" %}{% endblock %}
 
 {% if allow_execute_sql %}
-    <form class="sql core" action="{{ urls.database(database) }}/-/query" method="get" data-parameters-url="{{ urls.database(database) }}/-/query/parameters">
+    <form class="sql core" action="{{ urls.database(database) }}/-/query" method="get">
         <h3>Custom SQL query</h3>
-        <p class="sql-editor"><textarea id="sql-editor" name="sql">{% if tables %}select * from {{ tables[0].name|escape_sqlite }}{% else %}select sqlite_version(){% endif %}</textarea></p>
-        {% set parameter_names = [] %}
-        {% set parameter_values = {} %}
-        {% set sql_parameters_allow_expand = false %}
-        {% include "_sql_parameters.html" %}
+        <p><textarea id="sql-editor" name="sql">{% if tables %}select * from {{ tables[0].name|escape_sqlite }}{% else %}select sqlite_version(){% endif %}</textarea></p>
         <p>
             <button id="sql-format" type="button" hidden>Format SQL</button>
             <input type="submit" value="Run SQL">
@@ -58,13 +53,10 @@
             <li><a href="{{ urls.query(database, query.name) }}{% if query.fragment %}#{{ query.fragment }}{% endif %}" title="{{ query.description or query.sql }}">{{ query.title or query.name }}</a>{% if query.private %} 🔒{% endif %}</li>
         {% endfor %}
     </ul>
-    {% if queries_more %}
-        <p><a href="{{ urls.database(database) }}/-/queries">View {{ "{:,}".format(queries_count) }} quer{% if queries_count == 1 %}y{% else %}ies{% endif %}</a></p>
-    {% endif %}
 {% endif %}
 
 {% if tables %}
-<h2 id="tables">Tables <a style="font-weight: normal; font-size: 0.75em; padding-left: 0.5em;" href="{{ urls.database(database) }}/-/schema">schema</a></h2>
+<h2 id="tables">Tables</h2>
 {% endif %}
 
 {% for table in tables %}
@@ -95,11 +87,5 @@
 {% endif %}
 
 {% include "_codemirror_foot.html" %}
-{% include "_sql_parameter_scripts.html" %}
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  window.datasetteSqlParameters.setupSqlParameterRefresh({});
-});
-</script>
 
 {% endblock %}

datasette/templates/debug_actions.html

@@ -1,43 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Registered Actions{% endblock %}
-
-{% block content %}
-<h1>Registered actions</h1>
-
-{% set current_tab = "actions" %}
-{% include "_permissions_debug_tabs.html" %}
-
-<p style="margin-bottom: 2em;">
-  This Datasette instance has registered {{ data|length }} action{{ data|length != 1 and "s" or "" }}.
-  Actions are used by the permission system to control access to different features.
-</p>
-
-<table class="rows-and-columns">
-  <thead>
-    <tr>
-      <th>Name</th>
-      <th>Abbr</th>
-      <th>Description</th>
-      <th>Resource</th>
-      <th>Takes Parent</th>
-      <th>Takes Child</th>
-      <th>Also Requires</th>
-    </tr>
-  </thead>
-  <tbody>
-    {% for action in data %}
-    <tr>
-      <td><strong>{{ action.name }}</strong></td>
-      <td>{% if action.abbr %}<code>{{ action.abbr }}</code>{% endif %}</td>
-      <td>{{ action.description or "" }}</td>
-      <td>{% if action.resource_class %}<code>{{ action.resource_class }}</code>{% endif %}</td>
-      <td>{% if action.takes_parent %}✓{% endif %}</td>
-      <td>{% if action.takes_child %}✓{% endif %}</td>
-      <td>{% if action.also_requires %}<code>{{ action.also_requires }}</code>{% endif %}</td>
-    </tr>
-    {% endfor %}
-  </tbody>
-</table>
-
-{% endblock %}

datasette/templates/debug_allowed.html

@@ -5,14 +5,11 @@
 {% block extra_head %}
 <script src="{{ base_url }}-/static/json-format-highlight-1.0.1.js"></script>
 {% include "_permission_ui_styles.html" %}
-{% include "_debug_common_functions.html" %}
 {% endblock %}
 
 {% block content %}
-<h1>Allowed resources</h1>
 
-{% set current_tab = "allowed" %}
-{% include "_permissions_debug_tabs.html" %}
+<h1>Allowed Resources</h1>
 
 <p>Use this tool to check which resources the current actor is allowed to access for a given permission action. It queries the <code>/-/allowed.json</code> API endpoint.</p>
 
@@ -23,13 +20,13 @@
 {% endif %}
 
 <div class="permission-form">
-    <form id="allowed-form" method="get" action="{{ urls.path("-/allowed") }}">
+    <form id="allowed-form">
         <div class="form-section">
             <label for="action">Action (permission name):</label>
             <select id="action" name="action" required>
                 <option value="">Select an action...</option>
-                {% for action_name in supported_actions %}
-                <option value="{{ action_name }}">{{ action_name }}</option>
+                {% for permission_name in supported_actions %}
+                <option value="{{ permission_name }}">{{ permission_name }}</option>
                 {% endfor %}
             </select>
             <small>Only certain actions are supported by this endpoint</small>
@@ -44,7 +41,7 @@
         <div class="form-section">
             <label for="child">Filter by child (optional):</label>
             <input type="text" id="child" name="child" placeholder="e.g., table name">
-            <small>Filter results to a specific child resource (requires parent to be set)</small>
+            <small>Filter results to a specific child resource (requires parent)</small>
         </div>
 
         <div class="form-section">
@@ -82,19 +79,74 @@ const resultsContent = document.getElementById('results-content');
 const resultsCount = document.getElementById('results-count');
 const pagination = document.getElementById('pagination');
 const submitBtn = document.getElementById('submit-btn');
-const hasDebugPermission = {{ 'true' if has_debug_permission else 'false' }};
+let currentData = null;
+
+// Populate form from URL parameters on page load
+function populateFormFromURL() {
+    const params = new URLSearchParams(window.location.search);
+
+    const action = params.get('action');
+    if (action) {
+        document.getElementById('action').value = action;
+    }
+
+    const parent = params.get('parent');
+    if (parent) {
+        document.getElementById('parent').value = parent;
+    }
+
+    const child = params.get('child');
+    if (child) {
+        document.getElementById('child').value = child;
+    }
+
+    const pageSize = params.get('page_size');
+    if (pageSize) {
+        document.getElementById('page_size').value = pageSize;
+    }
+
+    const page = params.get('page');
+
+    // If parameters are present, automatically fetch results
+    if (action) {
+        fetchResults(page ? parseInt(page) : 1, false);
+    }
+}
+
+// Update URL with current form values and page
+function updateURL(page = 1) {
+    const formData = new FormData(form);
+    const params = new URLSearchParams();
+
+    for (const [key, value] of formData.entries()) {
+        if (value) {
+            params.append(key, value);
+        }
+    }
+
+    if (page > 1) {
+        params.set('page', page.toString());
+    }
+
+    const newURL = window.location.pathname + (params.toString() ? '?' + params.toString() : '');
+    window.history.pushState({}, '', newURL);
+}
+
+form.addEventListener('submit', async (ev) => {
+    ev.preventDefault();
+    updateURL(1);
+    await fetchResults(1, false);
+});
+
+// Handle browser back/forward
+window.addEventListener('popstate', () => {
+    populateFormFromURL();
+});
 
 // Populate form on initial load
-(function() {
-    const params = populateFormFromURL();
-    const action = params.get('action');
-    const page = params.get('page');
-    if (action) {
-        fetchResults(page ? parseInt(page) : 1);
-    }
-})();
+populateFormFromURL();
 
-async function fetchResults(page = 1) {
+async function fetchResults(page = 1, updateHistory = true) {
     submitBtn.disabled = true;
     submitBtn.textContent = 'Loading...';
 
@@ -122,6 +174,7 @@ async function fetchResults(page = 1) {
         const data = await response.json();
 
         if (response.ok) {
+            currentData = data;
             displayResults(data);
         } else {
             displayError(data);
@@ -149,9 +202,8 @@ function displayResults(data) {
         html += '<th>Resource Path</th>';
         html += '<th>Parent</th>';
         html += '<th>Child</th>';
-        if (hasDebugPermission) {
-            html += '<th>Reason</th>';
-        }
+        html += '<th>Reason</th>';
+        html += '<th>Source Plugin</th>';
         html += '</tr></thead>';
         html += '<tbody>';
 
@@ -160,14 +212,8 @@ function displayResults(data) {
             html += `<td><span class="resource-path">${escapeHtml(item.resource || '/')}</span></td>`;
             html += `<td>${escapeHtml(item.parent || '—')}</td>`;
             html += `<td>${escapeHtml(item.child || '—')}</td>`;
-            if (hasDebugPermission) {
-                // Display reason as JSON array
-                let reasonHtml = '—';
-                if (item.reason && Array.isArray(item.reason)) {
-                    reasonHtml = `<code>${escapeHtml(JSON.stringify(item.reason))}</code>`;
-                }
-                html += `<td>${reasonHtml}</td>`;
-            }
+            html += `<td>${escapeHtml(item.reason || '—')}</td>`;
+            html += `<td>${escapeHtml(item.source_plugin || '—')}</td>`;
             html += '</tr>';
         }
 
@@ -180,8 +226,13 @@ function displayResults(data) {
     if (data.previous_url || data.next_url) {
         if (data.previous_url) {
             const prevLink = document.createElement('a');
-            prevLink.href = data.previous_url;
+            prevLink.href = '#';
             prevLink.textContent = '← Previous';
+            prevLink.addEventListener('click', (e) => {
+                e.preventDefault();
+                updateURL(data.page - 1);
+                fetchResults(data.page - 1, false);
+            });
             pagination.appendChild(prevLink);
         }
 
@@ -191,14 +242,22 @@ function displayResults(data) {
 
         if (data.next_url) {
             const nextLink = document.createElement('a');
-            nextLink.href = data.next_url;
+            nextLink.href = '#';
             nextLink.textContent = 'Next →';
+            nextLink.addEventListener('click', (e) => {
+                e.preventDefault();
+                updateURL(data.page + 1);
+                fetchResults(data.page + 1, false);
+            });
             pagination.appendChild(nextLink);
         }
     }
 
     // Update raw JSON
     document.getElementById('raw-json').innerHTML = jsonFormatHighlight(data);
+
+    // Scroll to results
+    resultsContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
 }
 
 function displayError(data) {
@@ -209,21 +268,27 @@ function displayError(data) {
     resultsContent.innerHTML = `<div class="error-message">Error: ${escapeHtml(data.error || 'Unknown error')}</div>`;
 
     document.getElementById('raw-json').innerHTML = jsonFormatHighlight(data);
+
+    resultsContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
+}
+
+function escapeHtml(text) {
+    if (text === null || text === undefined) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
 }
 
 // Disable child input if parent is empty
 const parentInput = document.getElementById('parent');
 const childInput = document.getElementById('child');
 
-parentInput.addEventListener('input', () => {
-    childInput.disabled = !parentInput.value;
+childInput.addEventListener('focus', () => {
     if (!parentInput.value) {
-        childInput.value = '';
+        alert('Please specify a parent resource first before filtering by child resource.');
+        parentInput.focus();
     }
 });
-
-// Initialize disabled state
-childInput.disabled = !parentInput.value;
 </script>
 
 {% endblock %}

datasette/templates/debug_check.html

@@ -4,9 +4,34 @@
 
 {% block extra_head %}
 <script src="{{ base_url }}-/static/json-format-highlight-1.0.1.js"></script>
-{% include "_permission_ui_styles.html" %}
-{% include "_debug_common_functions.html" %}
 <style>
+.form-section {
+    margin-bottom: 1em;
+}
+.form-section label {
+    display: block;
+    margin-bottom: 0.3em;
+    font-weight: bold;
+}
+.form-section input[type="text"],
+.form-section select {
+    width: 100%;
+    max-width: 500px;
+    padding: 0.5em;
+    box-sizing: border-box;
+    border: 1px solid #ccc;
+    border-radius: 3px;
+}
+.form-section input[type="text"]:focus,
+.form-section select:focus {
+    outline: 2px solid #0066cc;
+    border-color: #0066cc;
+}
+.form-section small {
+    display: block;
+    margin-top: 0.3em;
+    color: #666;
+}
 #output {
     margin-top: 2em;
     padding: 1em;
@@ -48,14 +73,28 @@
 .details-section dd {
     margin-left: 1em;
 }
+#submit-btn {
+    padding: 0.6em 1.5em;
+    font-size: 1em;
+    background-color: #0066cc;
+    color: white;
+    border: none;
+    border-radius: 3px;
+    cursor: pointer;
+}
+#submit-btn:hover {
+    background-color: #0052a3;
+}
+#submit-btn:disabled {
+    background-color: #ccc;
+    cursor: not-allowed;
+}
 </style>
 {% endblock %}
 
 {% block content %}
-<h1>Permission check</h1>
 
-{% set current_tab = "check" %}
-{% include "_permissions_debug_tabs.html" %}
+<h1>Permission Check</h1>
 
 <p>Use this tool to test permission checks for the current actor. It queries the <code>/-/check.json</code> API endpoint.</p>
 
@@ -65,36 +104,32 @@
 <p>Current actor: <strong>anonymous (not logged in)</strong></p>
 {% endif %}
 
-<div class="permission-form">
-    <form id="check-form" method="get" action="{{ urls.path("-/check") }}">
-        <div class="form-section">
-            <label for="action">Action (permission name):</label>
-            <select id="action" name="action" required>
-                <option value="">Select an action...</option>
-                {% for action_name in sorted_actions %}
-                <option value="{{ action_name }}">{{ action_name }}</option>
-                {% endfor %}
-            </select>
-            <small>The permission action to check</small>
-        </div>
+<form id="check-form" class="core">
+    <div class="form-section">
+        <label for="action">Action (permission name):</label>
+        <select id="action" name="action" required>
+            <option value="">Select an action...</option>
+            {% for permission_name in sorted_permissions %}
+            <option value="{{ permission_name }}">{{ permission_name }}</option>
+            {% endfor %}
+        </select>
+        <small>The permission action to check</small>
+    </div>
 
-        <div class="form-section">
-            <label for="parent">Parent resource (optional):</label>
-            <input type="text" id="parent" name="parent" placeholder="e.g., database name">
-            <small>For database-level permissions, specify the database name</small>
-        </div>
+    <div class="form-section">
+        <label for="parent">Parent resource (optional):</label>
+        <input type="text" id="parent" name="parent" placeholder="e.g., database name">
+        <small>For database-level permissions, specify the database name</small>
+    </div>
 
-        <div class="form-section">
-            <label for="child">Child resource (optional):</label>
-            <input type="text" id="child" name="child" placeholder="e.g., table name">
-            <small>For table-level permissions, specify the table name (requires parent)</small>
-        </div>
+    <div class="form-section">
+        <label for="child">Child resource (optional):</label>
+        <input type="text" id="child" name="child" placeholder="e.g., table name">
+        <small>For table-level permissions, specify the table name (requires parent)</small>
+    </div>
 
-        <div class="form-actions">
-            <button type="submit" class="submit-btn" id="submit-btn">Check Permission</button>
-        </div>
-    </form>
-</div>
+    <button type="submit" id="submit-btn">Check Permission</button>
+</form>
 
 <div id="output" style="display: none;">
     <h2>Result: <span class="result-badge" id="result-badge"></span></h2>
@@ -123,6 +158,46 @@ const form = document.getElementById('check-form');
 const output = document.getElementById('output');
 const submitBtn = document.getElementById('submit-btn');
 
+// Populate form from URL parameters on page load
+function populateFormFromURL() {
+    const params = new URLSearchParams(window.location.search);
+
+    const action = params.get('action');
+    if (action) {
+        document.getElementById('action').value = action;
+    }
+
+    const parent = params.get('parent');
+    if (parent) {
+        document.getElementById('parent').value = parent;
+    }
+
+    const child = params.get('child');
+    if (child) {
+        document.getElementById('child').value = child;
+    }
+
+    // If parameters are present, automatically submit the form
+    if (action) {
+        performCheck();
+    }
+}
+
+// Update URL with current form values
+function updateURL() {
+    const formData = new FormData(form);
+    const params = new URLSearchParams();
+
+    for (const [key, value] of formData.entries()) {
+        if (value) {
+            params.append(key, value);
+        }
+    }
+
+    const newURL = window.location.pathname + (params.toString() ? '?' + params.toString() : '');
+    window.history.pushState({}, '', newURL);
+}
+
 async function performCheck() {
     submitBtn.disabled = true;
     submitBtn.textContent = 'Checking...';
@@ -159,14 +234,19 @@ async function performCheck() {
     }
 }
 
+form.addEventListener('submit', async (ev) => {
+    ev.preventDefault();
+    updateURL();
+    await performCheck();
+});
+
+// Handle browser back/forward
+window.addEventListener('popstate', () => {
+    populateFormFromURL();
+});
+
 // Populate form on initial load
-(function() {
-    const params = populateFormFromURL();
-    const action = params.get('action');
-    if (action) {
-        performCheck();
-    }
-})();
+populateFormFromURL();
 
 function displayResult(data) {
     output.style.display = 'block';

datasette/templates/debug_permissions_playground.html

@@ -1,165 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Debug permissions{% endblock %}
-
-{% block extra_head %}
-{% include "_permission_ui_styles.html" %}
-<style type="text/css">
-.check-result-true {
-    color: green;
-}
-.check-result-false {
-    color: red;
-}
-.check-result-no-opinion {
-    color: #aaa;
-}
-.check h2 {
-    font-size: 1em
-}
-.check-action, .check-when, .check-result {
-    font-size: 1.3em;
-}
-textarea {
-    height: 10em;
-    width: 95%;
-    box-sizing: border-box;
-    padding: 0.5em;
-    border: 2px dotted black;
-}
-.two-col {
-    display: inline-block;
-    width: 48%;
-}
-.two-col label {
-    width: 48%;
-}
-@media only screen and (max-width: 576px) {
-    .two-col {
-        width: 100%;
-    }
-}
-</style>
-{% endblock %}
-
-{% block content %}
-<h1>Permission playground</h1>
-
-{% set current_tab = "permissions" %}
-{% include "_permissions_debug_tabs.html" %}
-
-<p>This tool lets you simulate an actor and a permission check for that actor.</p>
-
-<div class="permission-form">
-    <form action="{{ urls.path('-/permissions') }}" id="debug-post" method="post">
-        <div class="two-col">
-            <div class="form-section">
-                <label>Actor</label>
-                <textarea name="actor">{% if actor_input %}{{ actor_input }}{% else %}{"id": "root"}{% endif %}</textarea>
-            </div>
-        </div>
-        <div class="two-col" style="vertical-align: top">
-            <div class="form-section">
-                <label for="permission">Action</label>
-                <select name="permission" id="permission">
-                    {% for permission in permissions %}
-                        <option value="{{ permission.name }}">{{ permission.name }}</option>
-                    {% endfor %}
-                </select>
-            </div>
-            <div class="form-section">
-                <label for="resource_1">Parent</label>
-                <input type="text" id="resource_1" name="resource_1" placeholder="e.g., database name">
-            </div>
-            <div class="form-section">
-                <label for="resource_2">Child</label>
-                <input type="text" id="resource_2" name="resource_2" placeholder="e.g., table name">
-            </div>
-        </div>
-        <div class="form-actions">
-            <button type="submit" class="submit-btn">Simulate permission check</button>
-        </div>
-        <pre style="margin-top: 1em" id="debugResult"></pre>
-    </form>
-</div>
-
-<script>
-var rawPerms = {{ permissions|tojson }};
-var permissions = Object.fromEntries(rawPerms.map(p => [p.name, p]));
-var permissionSelect = document.getElementById('permission');
-var resource1 = document.getElementById('resource_1');
-var resource2 = document.getElementById('resource_2');
-var resource1Section = resource1.closest('.form-section');
-var resource2Section = resource2.closest('.form-section');
-function updateResourceVisibility() {
-    var permission = permissionSelect.value;
-    var {takes_parent, takes_child} = permissions[permission];
-    resource1Section.style.display = takes_parent ? 'block' : 'none';
-    resource2Section.style.display = takes_child ? 'block' : 'none';
-}
-permissionSelect.addEventListener('change', updateResourceVisibility);
-updateResourceVisibility();
-
-// When #debug-post form is submitted, use fetch() to POST data
-var debugPost = document.getElementById('debug-post');
-var debugResult = document.getElementById('debugResult');
-debugPost.addEventListener('submit', function(ev) {
-    ev.preventDefault();
-    var formData = new FormData(debugPost);
-    fetch(debugPost.action, {
-        method: 'POST',
-        body: new URLSearchParams(formData),
-        headers: {
-            'Accept': 'application/json'
-        }
-    }).then(function(response) {
-        if (!response.ok) {
-            throw new Error('Request failed with status ' + response.status);
-        }
-        return response.json();
-    }).then(function(data) {
-        debugResult.innerText = JSON.stringify(data, null, 4);
-    }).catch(function(error) {
-        debugResult.innerText = JSON.stringify({ error: error.message }, null, 4);
-    });
-});
-</script>
-
-<h1>Recent permissions checks</h1>
-
-<p>
-    {% if filter != "all" %}<a href="?filter=all">All</a>{% else %}<strong>All</strong>{% endif %},
-    {% if filter != "exclude-yours" %}<a href="?filter=exclude-yours">Exclude yours</a>{% else %}<strong>Exclude yours</strong>{% endif %},
-    {% if filter != "only-yours" %}<a href="?filter=only-yours">Only yours</a>{% else %}<strong>Only yours</strong>{% endif %}
-</p>
-
-{% if permission_checks %}
-<table class="rows-and-columns permission-checks-table" id="permission-checks-table">
-    <thead>
-        <tr>
-            <th>When</th>
-            <th>Action</th>
-            <th>Parent</th>
-            <th>Child</th>
-            <th>Actor</th>
-            <th>Result</th>
-        </tr>
-    </thead>
-    <tbody>
-        {% for check in permission_checks %}
-            <tr>
-                <td><span style="font-size: 0.8em">{{ check.when.split('T', 1)[0] }}</span><br>{{ check.when.split('T', 1)[1].split('+', 1)[0].split('-', 1)[0].split('Z', 1)[0] }}</td>
-                <td><code>{{ check.action }}</code></td>
-                <td>{{ check.parent or '—' }}</td>
-                <td>{{ check.child or '—' }}</td>
-                <td>{% if check.actor %}<code>{{ check.actor|tojson }}</code>{% else %}<span class="check-actor-anon">anonymous</span>{% endif %}</td>
-                <td>{% if check.result %}<span class="check-result check-result-true">Allowed</span>{% elif check.result is none %}<span class="check-result check-result-no-opinion">No opinion</span>{% else %}<span class="check-result check-result-false">Denied</span>{% endif %}</td>
-            </tr>
-        {% endfor %}
-        </tbody>
-</table>
-{% else %}
-<p class="no-results">No permission checks have been recorded yet.</p>
-{% endif %}
-
-{% endblock %}

datasette/templates/debug_rules.html

@@ -5,14 +5,11 @@
 {% block extra_head %}
 <script src="{{ base_url }}-/static/json-format-highlight-1.0.1.js"></script>
 {% include "_permission_ui_styles.html" %}
-{% include "_debug_common_functions.html" %}
 {% endblock %}
 
 {% block content %}
-<h1>Permission rules</h1>
 
-{% set current_tab = "rules" %}
-{% include "_permissions_debug_tabs.html" %}
+<h1>Permission Rules</h1>
 
 <p>Use this tool to view the permission rules that allow the current actor to access resources for a given permission action. It queries the <code>/-/rules.json</code> API endpoint.</p>
 
@@ -23,13 +20,13 @@
 {% endif %}
 
 <div class="permission-form">
-    <form id="rules-form" method="get" action="{{ urls.path("-/rules") }}">
+    <form id="rules-form">
         <div class="form-section">
             <label for="action">Action (permission name):</label>
             <select id="action" name="action" required>
                 <option value="">Select an action...</option>
-                {% for action_name in sorted_actions %}
-                <option value="{{ action_name }}">{{ action_name }}</option>
+                {% for permission_name in sorted_permissions %}
+                <option value="{{ permission_name }}">{{ permission_name }}</option>
                 {% endfor %}
             </select>
             <small>The permission action to check</small>
@@ -70,18 +67,64 @@ const resultsContent = document.getElementById('results-content');
 const resultsCount = document.getElementById('results-count');
 const pagination = document.getElementById('pagination');
 const submitBtn = document.getElementById('submit-btn');
+let currentData = null;
+
+// Populate form from URL parameters on page load
+function populateFormFromURL() {
+    const params = new URLSearchParams(window.location.search);
+
+    const action = params.get('action');
+    if (action) {
+        document.getElementById('action').value = action;
+    }
+
+    const pageSize = params.get('page_size');
+    if (pageSize) {
+        document.getElementById('page_size').value = pageSize;
+    }
+
+    const page = params.get('page');
+
+    // If parameters are present, automatically fetch results
+    if (action) {
+        fetchResults(page ? parseInt(page) : 1, false);
+    }
+}
+
+// Update URL with current form values and page
+function updateURL(page = 1) {
+    const formData = new FormData(form);
+    const params = new URLSearchParams();
+
+    for (const [key, value] of formData.entries()) {
+        if (value) {
+            params.append(key, value);
+        }
+    }
+
+    if (page > 1) {
+        params.set('page', page.toString());
+    }
+
+    const newURL = window.location.pathname + (params.toString() ? '?' + params.toString() : '');
+    window.history.pushState({}, '', newURL);
+}
+
+form.addEventListener('submit', async (ev) => {
+    ev.preventDefault();
+    updateURL(1);
+    await fetchResults(1, false);
+});
+
+// Handle browser back/forward
+window.addEventListener('popstate', () => {
+    populateFormFromURL();
+});
 
 // Populate form on initial load
-(function() {
-    const params = populateFormFromURL();
-    const action = params.get('action');
-    const page = params.get('page');
-    if (action) {
-        fetchResults(page ? parseInt(page) : 1);
-    }
-})();
+populateFormFromURL();
 
-async function fetchResults(page = 1) {
+async function fetchResults(page = 1, updateHistory = true) {
     submitBtn.disabled = true;
     submitBtn.textContent = 'Loading...';
 
@@ -109,6 +152,7 @@ async function fetchResults(page = 1) {
         const data = await response.json();
 
         if (response.ok) {
+            currentData = data;
             displayResults(data);
         } else {
             displayError(data);
@@ -137,8 +181,8 @@ function displayResults(data) {
         html += '<th>Resource Path</th>';
         html += '<th>Parent</th>';
         html += '<th>Child</th>';
-        html += '<th>Source Plugin</th>';
         html += '<th>Reason</th>';
+        html += '<th>Source Plugin</th>';
         html += '</tr></thead>';
         html += '<tbody>';
 
@@ -153,8 +197,8 @@ function displayResults(data) {
             html += `<td><span class="resource-path">${escapeHtml(item.resource || '/')}</span></td>`;
             html += `<td>${escapeHtml(item.parent || '—')}</td>`;
             html += `<td>${escapeHtml(item.child || '—')}</td>`;
-            html += `<td>${escapeHtml(item.source_plugin || '—')}</td>`;
             html += `<td>${escapeHtml(item.reason || '—')}</td>`;
+            html += `<td>${escapeHtml(item.source_plugin || '—')}</td>`;
             html += '</tr>';
         }
 
@@ -167,8 +211,13 @@ function displayResults(data) {
     if (data.previous_url || data.next_url) {
         if (data.previous_url) {
             const prevLink = document.createElement('a');
-            prevLink.href = data.previous_url;
+            prevLink.href = '#';
             prevLink.textContent = '← Previous';
+            prevLink.addEventListener('click', (e) => {
+                e.preventDefault();
+                updateURL(data.page - 1);
+                fetchResults(data.page - 1, false);
+            });
             pagination.appendChild(prevLink);
         }
 
@@ -178,14 +227,22 @@ function displayResults(data) {
 
         if (data.next_url) {
             const nextLink = document.createElement('a');
-            nextLink.href = data.next_url;
+            nextLink.href = '#';
             nextLink.textContent = 'Next →';
+            nextLink.addEventListener('click', (e) => {
+                e.preventDefault();
+                updateURL(data.page + 1);
+                fetchResults(data.page + 1, false);
+            });
             pagination.appendChild(nextLink);
         }
     }
 
     // Update raw JSON
     document.getElementById('raw-json').innerHTML = jsonFormatHighlight(data);
+
+    // Scroll to results
+    resultsContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
 }
 
 function displayError(data) {
@@ -196,8 +253,16 @@ function displayError(data) {
     resultsContent.innerHTML = `<div class="error-message">Error: ${escapeHtml(data.error || 'Unknown error')}</div>`;
 
     document.getElementById('raw-json').innerHTML = jsonFormatHighlight(data);
+
+    resultsContainer.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
 }
 
+function escapeHtml(text) {
+    if (text === null || text === undefined) return '';
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
 </script>
 
 {% endblock %}

datasette/templates/execute_write.html

@@ -1,288 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Write to this database{% endblock %}
-
-{% block extra_head %}
-{{- super() -}}
-{% include "_codemirror.html" %}
-<style>
-.execute-write-template-menu {
-    margin: 0.9rem 0 0.8rem;
-    max-width: 52rem;
-}
-.execute-write-template-menu summary {
-    cursor: pointer;
-    font-weight: 600;
-    margin-bottom: 0.35rem;
-}
-.execute-write-template-controls {
-    align-items: center;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.4rem;
-    margin: 0.4rem 0 0.7rem;
-}
-.execute-write-template-menu .execute-write-template-controls label {
-    margin-right: 0.25rem;
-    width: auto;
-}
-.execute-write-template-controls select,
-.execute-write-template-controls button[type=button] {
-    box-sizing: border-box;
-    font-size: 0.78rem;
-    height: 2rem;
-    line-height: 1.1;
-    padding: 0.35rem 0.55rem;
-}
-.execute-write-template-controls select {
-    background-color: #fff;
-    border: 1px solid #777;
-    border-radius: 0.25rem;
-    min-width: 13rem;
-}
-.execute-write-submit-row {
-    align-items: center;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.45rem 0.75rem;
-}
-.execute-write-submit-row [hidden] {
-    display: none;
-}
-form.sql.core input[data-execute-write-submit]:disabled {
-    background: #d0d7de;
-    border-color: #b6c0cc;
-    color: #5f6975;
-    cursor: not-allowed;
-    opacity: 1;
-}
-.execute-write-disabled-reason {
-    color: #4f5b6d;
-    font-size: 0.85rem;
-}
-</style>
-{% include "_execute_write_analysis_styles.html" %}
-{% include "_sql_parameter_styles.html" %}
-{% endblock %}
-
-{% block body_class %}execute-write db-{{ database|to_css_class }}{% endblock %}
-
-{% block crumbs %}
-{{ crumbs.nav(request=request, database=database) }}
-{% endblock %}
-
-{% block content %}
-
-<h1 style="padding-left: 10px; border-left: 10px solid #{{ database_color }}">Write to this database</h1>
-
-<p>Execute SQL to insert, update or delete rows in this database.</p>
-
-{% if execution_message %}
-    <p class="{% if execution_ok %}message-info{% else %}message-error{% endif %}">{{ execution_message }}{% for link in execution_links %} <a href="{{ link.href }}">{{ link.label }}</a>{% endfor %}</p>
-{% endif %}
-
-<form class="sql core" action="{{ urls.database(database) }}/-/execute-write" method="post" data-analyze-url="{{ urls.database(database) }}/-/execute-write/analyze">
-    {% if write_template_tables %}
-        <div class="execute-write-template-menu">
-            <details>
-                <summary>Start with a template</summary>
-                <p class="execute-write-template-controls">
-                    <label for="execute-write-template-table">Table</label>
-                    <select id="execute-write-template-table">
-                        {% for table_name, table in write_template_tables|dictsort %}
-                            <option value="{{ table_name }}"{% for operation, template_sql in table.templates|dictsort %} data-template-{{ operation }}-sql="{{ template_sql }}"{% endfor %}>{{ table_name }}</option>
-                        {% endfor %}
-                    </select>
-                    {% for operation in write_template_operations %}
-                        <button type="button" data-sql-template="{{ operation.name }}">{{ operation.label }}</button>
-                    {% endfor %}
-                </p>
-            </details>
-        </div>
-    {% else %}
-        <p class="message-warning execute-write-template-unavailable">You don't currently have permission to insert, edit or delete from any tables.</p>
-    {% endif %}
-
-    <p class="sql-editor"><textarea id="sql-editor" name="sql"{% if sql %} style="height: {{ sql.split("\n")|length + 2 }}em"{% endif %}>{{ sql }}</textarea></p>
-
-    {% set sql_parameters_section_id = "execute-write-parameters-section" %}
-    {% set sql_parameters_allow_expand = true %}
-    {% include "_sql_parameters.html" %}
-
-    <div id="execute-write-analysis-section">
-        <h2>Query operations</h2>
-        {% if analysis_error %}
-            <p class="message-error">{{ analysis_error }}</p>
-        {% elif analysis_rows %}
-            <div class="table-wrapper"><table class="execute-write-analysis">
-                <thead>
-                    <tr>
-                        <th scope="col">Operation</th>
-                        <th scope="col">Database</th>
-                        <th scope="col">Table</th>
-                        <th scope="col">Required permission</th>
-                        <th scope="col">Allowed</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    {% for row in analysis_rows %}
-                        <tr>
-                            <td><code>{{ row.operation }}</code></td>
-                            <td><code>{{ row.database }}</code></td>
-                            <td><code>{{ row.table }}</code></td>
-                            <td>{% if row.required_permission %}<code>{{ row.required_permission }}</code>{% endif %}</td>
-                            <td>{% if row.allowed is none %}{% elif row.allowed %}<span class="execute-write-analysis-allowed">yes</span>{% else %}<span class="execute-write-analysis-denied">no</span>{% endif %}</td>
-                        </tr>
-                    {% endfor %}
-                </tbody>
-            </table></div>
-        {% else %}
-            <p>Analysis will show each affected table and required permission.</p>
-        {% endif %}
-    </div>
-
-    <p class="execute-write-submit-row"{% if save_query_base_url %} data-save-query-base-url="{{ save_query_base_url }}"{% endif %}>
-        <input type="submit" value="Execute" data-execute-write-submit aria-describedby="execute-write-disabled-reason"{% if execute_disabled %} disabled{% endif %}>
-        <span id="execute-write-disabled-reason" class="execute-write-disabled-reason" data-execute-write-disabled-reason aria-live="polite"{% if not execute_disabled_reason %} hidden{% endif %}>{{ execute_disabled_reason or "" }}</span>
-        {% if save_query_url %}<a href="{{ save_query_url }}" class="save-query" data-save-query-link>Save this query</a>{% endif %}
-    </p>
-</form>
-
-<script>
-const executeWriteSqlInput = document.querySelector("textarea#sql-editor");
-if (executeWriteSqlInput && !executeWriteSqlInput.value) {
-  executeWriteSqlInput.value = "\n\n\n";
-}
-</script>
-
-{% include "_codemirror_foot.html" %}
-{% include "_sql_parameter_scripts.html" %}
-{% include "_execute_write_analysis_scripts.html" %}
-
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  const form = document.querySelector("form.sql.core");
-  const analysisSection = document.querySelector("#execute-write-analysis-section");
-  const submitButton = form
-    ? form.querySelector("[data-execute-write-submit]")
-    : null;
-  const submitDisabledReason = form
-    ? form.querySelector("[data-execute-write-disabled-reason]")
-    : null;
-  const submitRow = form
-    ? form.querySelector(".execute-write-submit-row")
-    : null;
-  let saveQueryLink = form
-    ? form.querySelector("[data-save-query-link]")
-    : null;
-
-  function updateSubmitState(data) {
-    if (submitButton) {
-      submitButton.disabled = data.execute_disabled;
-    }
-    if (!submitDisabledReason) {
-      return;
-    }
-    const reason = data.execute_disabled_reason || "";
-    submitDisabledReason.textContent = reason;
-    submitDisabledReason.hidden = !reason;
-  }
-
-  function updateSaveQueryLink(data) {
-    if (!submitRow || !submitRow.dataset.saveQueryBaseUrl) {
-      return;
-    }
-    const sql = window.editor
-      ? window.editor.state.doc.toString()
-      : executeWriteSqlInput.value;
-    if (!sql.trim() || !data.ok || data.execute_disabled) {
-      if (saveQueryLink) {
-        saveQueryLink.remove();
-        saveQueryLink = null;
-      }
-      return;
-    }
-    if (!saveQueryLink) {
-      saveQueryLink = document.createElement("a");
-      saveQueryLink.className = "save-query";
-      saveQueryLink.setAttribute("data-save-query-link", "");
-      saveQueryLink.textContent = "Save this query";
-      submitRow.appendChild(saveQueryLink);
-    }
-    const url = new URL(
-      submitRow.dataset.saveQueryBaseUrl,
-      window.location.href
-    );
-    url.searchParams.set("sql", sql);
-    saveQueryLink.href = url.pathname + url.search + url.hash;
-  }
-
-  window.datasetteSqlParameters.setupSqlParameterRefresh({
-    form,
-    url: form.dataset.analyzeUrl,
-    allowExpand: true,
-    onData(data) {
-      window.datasetteSqlAnalysis.renderAnalysis(analysisSection, data);
-      updateSubmitState(data);
-      updateSaveQueryLink(data);
-    },
-    onError(error) {
-      window.datasetteSqlAnalysis.renderAnalysis(analysisSection, {
-        analysis_error: error.message,
-        analysis_rows: [],
-      });
-      updateSubmitState({
-        execute_disabled: true,
-        execute_disabled_reason: error.message,
-      });
-      updateSaveQueryLink({ ok: false, execute_disabled: true });
-    },
-  });
-});
-</script>
-
-{% if write_template_tables %}
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  const tableSelect = document.querySelector("#execute-write-template-table");
-  const templateButtons = document.querySelectorAll("[data-sql-template]");
-
-  function dataKey(operation) {
-    return `template${operation.charAt(0).toUpperCase()}${operation.slice(1)}Sql`;
-  }
-
-  function selectedOption() {
-    return tableSelect ? tableSelect.options[tableSelect.selectedIndex] : null;
-  }
-
-  function templateSql(operation) {
-    const option = selectedOption();
-    return option ? option.dataset[dataKey(operation)] || "" : "";
-  }
-
-  function updateTemplateButtons() {
-    templateButtons.forEach((button) => {
-      button.hidden = !templateSql(button.dataset.sqlTemplate);
-    });
-  }
-
-  templateButtons.forEach((button) => {
-    button.addEventListener("click", () => {
-      const sql = templateSql(button.dataset.sqlTemplate);
-      if (!sql) {
-        return;
-      }
-      const url = new URL(window.location.href);
-      url.searchParams.set("sql", sql);
-      window.location.href = url.toString();
-    });
-  });
-  if (tableSelect) {
-    tableSelect.addEventListener("change", updateTemplateButtons);
-  }
-  updateTemplateButtons();
-});
-</script>
-{% endif %}
-
-{% endblock %}

datasette/templates/logout.html

@@ -10,6 +10,7 @@
 
 <form class="core" action="{{ urls.logout() }}" method="post">
     <div>
+        <input type="hidden" name="csrftoken" value="{{ csrftoken() }}">
         <input type="submit" value="Log out">
     </div>
 </form>

datasette/templates/messages_debug.html

@@ -19,6 +19,7 @@
                 <option>all</option>
             </select>
         </div>
+        <input type="hidden" name="csrftoken" value="{{ csrftoken() }}">
         <input type="submit" value="Add message">
     </div>
 </form>

datasette/templates/permissions_debug.html

@@ -0,0 +1,149 @@
+{% extends "base.html" %}
+
+{% block title %}Debug permissions{% endblock %}
+
+{% block extra_head %}
+<style type="text/css">
+.check-result-true {
+    color: green;
+}
+.check-result-false {
+    color: red;
+}
+.check-result-no-opinion {
+    color: #aaa;
+}
+.check h2 {
+    font-size: 1em
+}
+.check-action, .check-when, .check-result {
+    font-size: 1.3em;
+}
+textarea {
+    height: 10em;
+    width: 95%;
+    box-sizing: border-box;
+    padding: 0.5em;
+    border: 2px dotted black;
+}
+.two-col {
+    display: inline-block;
+    width: 48%;
+}
+.two-col label {
+    width: 48%;
+}
+@media only screen and (max-width: 576px) {
+    .two-col {
+        width: 100%;
+    }
+}
+</style>
+{% endblock %}
+
+{% block content %}
+
+<h1>Permission check testing tool</h1>
+
+<p>This tool lets you simulate an actor and a permission check for that actor.</p>
+
+<form class="core" action="{{ urls.path('-/permissions') }}" id="debug-post" method="post" style="margin-bottom: 1em">
+    <input type="hidden" name="csrftoken" value="{{ csrftoken() }}">
+    <div class="two-col">
+        <p><label>Actor</label></p>
+        <textarea name="actor">{% if actor_input %}{{ actor_input }}{% else %}{"id": "root"}{% endif %}</textarea>
+    </div>
+    <div class="two-col" style="vertical-align: top">
+        <p><label for="permission" style="display:block">Permission</label>
+        <select name="permission" id="permission">
+            {% for permission in permissions %}
+                <option value="{{ permission.name }}">{{ permission.name }} (default {{ permission.default }})</option>
+            {% endfor %}
+        </select>
+        <p><label for="resource_1">Database name</label><input type="text" id="resource_1" name="resource_1"></p>
+        <p><label for="resource_2">Table or query name</label><input type="text" id="resource_2" name="resource_2"></p>
+    </div>
+    <div style="margin-top: 1em;">
+        <input type="submit" value="Simulate permission check">
+    </div>
+    <pre style="margin-top: 1em" id="debugResult"></pre>
+</form>
+
+<script>
+var rawPerms = {{ permissions|tojson }};
+var permissions = Object.fromEntries(rawPerms.map(p => [p.name, p]));
+var permissionSelect = document.getElementById('permission');
+var resource1 = document.getElementById('resource_1');
+var resource2 = document.getElementById('resource_2');
+function updateResourceVisibility() {
+    var permission = permissionSelect.value;
+    var {takes_database, takes_resource} = permissions[permission];
+    if (takes_database) {
+        resource1.closest('p').style.display = 'block';
+    } else {
+        resource1.closest('p').style.display = 'none';
+    }
+    if (takes_resource) {
+        resource2.closest('p').style.display = 'block';
+    } else {
+        resource2.closest('p').style.display = 'none';
+    }
+}
+permissionSelect.addEventListener('change', updateResourceVisibility);
+updateResourceVisibility();
+
+// When #debug-post form is submitted, use fetch() to POST data
+var debugPost = document.getElementById('debug-post');
+var debugResult = document.getElementById('debugResult');
+debugPost.addEventListener('submit', function(ev) {
+    ev.preventDefault();
+    var formData = new FormData(debugPost);
+    console.log(formData);
+    fetch(debugPost.action, {
+        method: 'POST',
+        body: new URLSearchParams(formData),
+    }).then(function(response) {
+        return response.json();
+    }).then(function(data) {
+        debugResult.innerText = JSON.stringify(data, null, 4);
+    });
+});
+</script>
+
+<h1>Recent permissions checks</h1>
+
+<p>
+    {% if filter != "all" %}<a href="?filter=all">All</a>{% else %}<strong>All</strong>{% endif %},
+    {% if filter != "exclude-yours" %}<a href="?filter=exclude-yours">Exclude yours</a>{% else %}<strong>Exclude yours</strong>{% endif %},
+    {% if filter != "only-yours" %}<a href="?filter=only-yours">Only yours</a>{% else %}<strong>Only yours</strong>{% endif %}
+</p>
+
+{% for check in permission_checks %}
+    <div class="check">
+        <h2>
+            <span class="check-action">{{ check.action }}</span>
+            checked at
+            <span class="check-when">{{ check.when }}</span>
+            {% if check.result %}
+                <span class="check-result check-result-true">✓</span>
+            {% elif check.result is none %}
+                <span class="check-result check-result-no-opinion">none</span>
+            {% else %}
+                <span class="check-result check-result-false">✗</span>
+            {% endif %}
+            {% if check.used_default %}
+                <span class="check-used-default">(used default)</span>
+            {% endif %}
+        </h2>
+        <p><strong>Actor:</strong> {{ check.actor|tojson }}</p>
+        {% if check.resource %}
+            <p><strong>Resource:</strong> {{ check.resource }}</p>
+        {% endif %}
+    </div>
+{% endfor %}
+
+<h1>All registered permissions</h1>
+
+<pre>{{ permissions|tojson(2) }}</pre>
+
+{% endblock %}

datasette/templates/query.html

@@ -14,10 +14,9 @@
 </style>
 {% endif %}
 {% include "_codemirror.html" %}
-{% include "_sql_parameter_styles.html" %}
 {% endblock %}
 
-{% block body_class %}query db-{{ database|to_css_class }}{% if stored_query %} query-{{ stored_query|to_css_class }}{% endif %}{% endblock %}
+{% block body_class %}query db-{{ database|to_css_class }}{% if canned_query %} query-{{ canned_query|to_css_class }}{% endif %}{% endblock %}
 
 {% block crumbs %}
 {{ crumbs.nav(request=request, database=database) }}
@@ -25,19 +24,19 @@
 
 {% block content %}
 
-{% if stored_query_write and db_is_immutable %}
+{% if canned_query_write and db_is_immutable %}
     <p class="message-error">This query cannot be executed because the database is immutable.</p>
 {% endif %}
 
-<h1 style="padding-left: 10px; border-left: 10px solid #{{ database_color }}">{{ metadata.title or database }}{% if stored_query and not metadata.title %}: {{ stored_query }}{% endif %}{% if private %} 🔒{% endif %}</h1>
+<h1 style="padding-left: 10px; border-left: 10px solid #{{ database_color }}">{{ metadata.title or database }}{% if canned_query and not metadata.title %}: {{ canned_query }}{% endif %}{% if private %} 🔒{% endif %}</h1>
 {% set action_links, action_title = query_actions(), "Query actions" %}
 {% include "_action_menu.html" %}
 
-{% if stored_query %}{{ top_stored_query() }}{% else %}{{ top_query() }}{% endif %}
+{% if canned_query %}{{ top_canned_query() }}{% else %}{{ top_query() }}{% endif %}
 
 {% block description_source_license %}{% include "_description_source_license.html" %}{% endblock %}
 
-<form class="sql core" action="{{ urls.database(database) }}{% if stored_query %}/{{ stored_query }}{% endif %}" method="{% if stored_query_write %}post{% else %}get{% endif %}" data-parameters-url="{{ urls.database(database) }}/-/query/parameters">
+<form class="sql core" action="{{ urls.database(database) }}{% if canned_query %}/{{ canned_query }}{% endif %}" method="{% if canned_query_write %}post{% else %}get{% endif %}">
     <h3>Custom SQL query{% if display_rows %} returning {% if truncated %}more than {% endif %}{{ "{:,}".format(display_rows|length) }} row{% if display_rows|length == 1 %}{% else %}s{% endif %}{% endif %}{% if not query_error %}
         <span class="show-hide-sql">(<a href="{{ show_hide_link }}">{{ show_hide_text }}</a>)</span>
     {% endif %}</h3>
@@ -46,28 +45,30 @@
     {% endif %}
     {% if not hide_sql %}
         {% if editable and allow_execute_sql %}
-            <p class="sql-editor"><textarea id="sql-editor" name="sql"{% if query and query.sql %} style="height: {{ query.sql.split("\n")|length + 2 }}em"{% endif %}
-            >{% if query and query.sql %}{{ query.sql }}{% elif tables %}select * from {{ tables[0].name|escape_sqlite }}{% endif %}</textarea></p>
+            <p><textarea id="sql-editor" name="sql"{% if query and query.sql %} style="height: {{ query.sql.split("\n")|length + 2 }}em"{% endif %}
+            >{% if query and query.sql %}{{ query.sql }}{% else %}select * from {{ tables[0].name|escape_sqlite }}{% endif %}</textarea></p>
         {% else %}
             <pre id="sql-query">{% if query %}{{ query.sql }}{% endif %}</pre>
         {% endif %}
     {% else %}
-        {% if not stored_query %}
+        {% if not canned_query %}
             <input type="hidden" name="sql"
-                value="{% if query and query.sql %}{{ query.sql }}{% elif tables %}select * from {{ tables[0].name|escape_sqlite }}{% endif %}"
+                value="{% if query and query.sql %}{{ query.sql }}{% else %}select * from {{ tables[0].name|escape_sqlite }}{% endif %}"
             >
         {% endif %}
     {% endif %}
-    {% set parameter_names = named_parameter_values.keys()|list %}
-    {% set parameter_values = named_parameter_values %}
-    {% set sql_parameters_allow_expand = false %}
-    {% include "_sql_parameters.html" %}
+    {% if named_parameter_values %}
+        <h3>Query parameters</h3>
+        {% for name, value in named_parameter_values.items() %}
+            <p><label for="qp{{ loop.index }}">{{ name }}</label> <input type="text" id="qp{{ loop.index }}" name="{{ name }}" value="{{ value }}"></p>
+        {% endfor %}
+    {% endif %}
     <p>
         {% if not hide_sql %}<button id="sql-format" type="button" hidden>Format SQL</button>{% endif %}
-        <input type="submit" value="Run SQL"{% if stored_query_write and db_is_immutable %} disabled{% endif %}>
+        {% if canned_query_write %}<input type="hidden" name="csrftoken" value="{{ csrftoken() }}">{% endif %}
+        <input type="submit" value="Run SQL"{% if canned_query_write and db_is_immutable %} disabled{% endif %}>
         {{ show_hide_hidden }}
-        {% if save_query_url %}<a href="{{ save_query_url }}" class="save-query">Save this query</a>{% endif %}
-        {% if stored_query and edit_sql_url %}<a href="{{ edit_sql_url }}" class="stored-query-edit-sql">Edit SQL</a>{% endif %}
+        {% if canned_query and edit_sql_url %}<a href="{{ edit_sql_url }}" class="canned-query-edit-sql">Edit SQL</a>{% endif %}
     </p>
 </form>
 
@@ -90,17 +91,11 @@
     </tbody>
 </table></div>
 {% else %}
-    {% if not stored_query_write and not error %}
+    {% if not canned_query_write and not error %}
         <p class="zero-results">0 results</p>
     {% endif %}
 {% endif %}
 
 {% include "_codemirror_foot.html" %}
-{% include "_sql_parameter_scripts.html" %}
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  window.datasetteSqlParameters.setupSqlParameterRefresh({});
-});
-</script>
 
 {% endblock %}

datasette/templates/query_create.html

@@ -1,295 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}Create query{% endblock %}
-
-{% block extra_head %}
-{{- super() -}}
-{% include "_codemirror.html" %}
-{% include "_execute_write_analysis_styles.html" %}
-<style>
-.query-create-page {
-    max-width: 64rem;
-}
-.query-create-form {
-    --query-create-label-width: clamp(7rem, 18vw, 10rem);
-    --query-create-column-gap: 0.8rem;
-    --query-create-control-width: minmax(16rem, 1fr);
-}
-.query-create-fields {
-    margin: 0 0 0.85rem;
-    max-width: 52rem;
-}
-.query-create-field {
-    align-items: start;
-    column-gap: var(--query-create-column-gap);
-    display: grid;
-    grid-template-columns: var(--query-create-label-width) var(--query-create-control-width);
-    margin: 0 0 0.65rem;
-}
-.query-create-field label {
-    padding-top: 0.55rem;
-    width: auto;
-}
-.query-create-field input[type=text],
-.query-create-field textarea {
-    box-sizing: border-box;
-    width: 100%;
-}
-form.sql .query-create-field textarea {
-    width: 100%;
-}
-.query-create-url-control {
-    align-items: center;
-    box-sizing: border-box;
-    display: grid;
-    gap: 0.35rem;
-    grid-template-columns: max-content minmax(12rem, 1fr);
-    width: 100%;
-}
-.query-create-url-prefix {
-    color: #4f5b6d;
-    font-family: var(--font-monospace, monospace);
-    white-space: nowrap;
-}
-.query-create-url-control input[type=text] {
-    border: 1px solid #ccc;
-    border-radius: 3px;
-}
-.query-create-field textarea {
-    border: 1px solid #ccc;
-    border-radius: 3px;
-    display: block;
-    font-family: Helvetica, sans-serif;
-    font-size: 1em;
-    min-height: 5rem;
-    padding: 9px 4px;
-    resize: vertical;
-}
-form.sql .query-create-sql {
-    column-gap: var(--query-create-column-gap);
-    display: grid;
-    grid-template-columns: var(--query-create-label-width) var(--query-create-control-width);
-    margin: 0.9rem 0 0.75rem;
-    max-width: 52rem;
-}
-.query-create-sql .cm-editor,
-form.sql .query-create-sql textarea#sql-editor {
-    grid-column: 2;
-    width: 100%;
-}
-.query-create-options {
-    align-items: center;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.8rem 1.4rem;
-    margin: 0 0 0.9rem calc(var(--query-create-label-width) + var(--query-create-column-gap));
-    max-width: calc(52rem - var(--query-create-label-width) - var(--query-create-column-gap));
-}
-.query-create-options label {
-    align-items: center;
-    display: inline-flex;
-    gap: 0.35rem;
-    width: auto;
-}
-.query-create-options input[type=checkbox] {
-    margin: 0;
-}
-.query-create-option-note,
-.query-create-analysis-note {
-    color: #4f5b6d;
-    flex-basis: 100%;
-    font-size: 0.82rem;
-}
-.query-create-option-note {
-    margin: -0.45rem 0 0;
-}
-.query-create-analysis-note {
-    margin: 0;
-}
-.query-create-analysis {
-    margin-top: 0.8rem;
-}
-.query-create-submit {
-    margin-left: calc(var(--query-create-label-width) + var(--query-create-column-gap));
-    margin-bottom: 0.9rem;
-    margin-top: 1rem;
-}
-@media (max-width: 560px) {
-    .query-create-form {
-        --query-create-label-width: 1fr;
-        --query-create-column-gap: 0;
-    }
-    .query-create-field {
-        grid-template-columns: 1fr;
-        row-gap: 0.25rem;
-    }
-    .query-create-field label {
-        padding-top: 0;
-    }
-    form.sql .query-create-sql {
-        grid-template-columns: 1fr;
-    }
-    .query-create-sql .cm-editor,
-    form.sql .query-create-sql textarea#sql-editor {
-        grid-column: 1;
-    }
-    .query-create-options,
-    .query-create-submit {
-        margin-left: 0;
-    }
-}
-</style>
-{% endblock %}
-
-{% block body_class %}query-create db-{{ database|to_css_class }}{% endblock %}
-
-{% block crumbs %}
-{{ crumbs.nav(request=request, database=database) }}
-{% endblock %}
-
-{% block content %}
-
-<div class="query-create-page">
-
-<h1 style="padding-left: 10px; border-left: 10px solid #{{ database_color }}">Create query</h1>
-
-<form class="sql core query-create-form" action="{{ urls.database(database) }}/-/queries/store" method="post" data-analyze-url="{{ urls.database(database) }}/-/queries/analyze">
-    <div class="query-create-fields">
-        <p class="query-create-field"><label for="query-title">Title</label> <input id="query-title" name="title" type="text" value="{{ title or "" }}"></p>
-        <p class="query-create-field"><label for="query-url-slug">URL</label> <span class="query-create-url-control"><span class="query-create-url-prefix">{{ urls.database(database) }}/</span><input id="query-url-slug" name="name" type="text" value="{{ name or "" }}"></span></p>
-        <p class="query-create-field"><label for="query-description">Description</label> <textarea id="query-description" name="description" rows="3">{{ description or "" }}</textarea></p>
-    </div>
-
-    <p class="query-create-sql sql-editor"><textarea id="sql-editor" name="sql"{% if sql %} style="height: {{ sql.split("\n")|length + 2 }}em"{% endif %}>{{ sql }}</textarea></p>
-
-    <p class="query-create-options">
-        <span class="query-create-analysis-note" data-query-create-analysis-note aria-live="polite">{% if analysis_error %}This query cannot be saved until the SQL is valid.{% elif not has_sql %}Enter SQL to analyze this query.{% elif analysis_is_write %}This query updates data in the database.{% else %}This is a read-only query.{% endif %}</span>
-        <input type="hidden" name="is_private" value="0">
-        <label><input type="checkbox" name="is_private" value="1"{% if is_private %} checked{% endif %}> Private</label>
-        <span class="query-create-option-note">Queries marked private can only be seen by you, their creator.</span>
-    </p>
-    <p class="query-create-submit"><input type="submit" value="Save query" data-query-create-submit{% if save_disabled %} disabled{% endif %}></p>
-
-    <div class="query-create-analysis" id="query-create-analysis-section"{% if not has_sql %} hidden{% endif %}>
-        {% if has_sql %}
-            <h2>Query operations</h2>
-            {% if analysis_error %}
-                <p class="message-error">{{ analysis_error }}</p>
-            {% elif analysis_rows %}
-                <div class="table-wrapper"><table class="execute-write-analysis">
-                    <thead>
-                        <tr>
-                            <th scope="col">Operation</th>
-                            <th scope="col">Database</th>
-                            <th scope="col">Table</th>
-                            <th scope="col">Required permission</th>
-                            <th scope="col">Allowed</th>
-                        </tr>
-                    </thead>
-                    <tbody>
-                        {% for row in analysis_rows %}
-                            <tr>
-                                <td><code>{{ row.operation }}</code></td>
-                                <td><code>{{ row.database }}</code></td>
-                                <td><code>{{ row.table }}</code></td>
-                                <td>{% if row.required_permission %}<code>{{ row.required_permission }}</code>{% else %}<span class="execute-write-analysis-na">n/a</span>{% endif %}</td>
-                                <td>{% if row.allowed is none %}<span class="execute-write-analysis-na">n/a</span>{% elif row.allowed %}<span class="execute-write-analysis-allowed">yes</span>{% else %}<span class="execute-write-analysis-denied">no</span>{% endif %}</td>
-                            </tr>
-                        {% endfor %}
-                    </tbody>
-                </table></div>
-            {% else %}
-                <p>Analysis will show each affected table and required permission.</p>
-            {% endif %}
-        {% endif %}
-    </div>
-</form>
-
-</div>
-
-{% include "_codemirror_foot.html" %}
-{% include "_sql_parameter_scripts.html" %}
-{% include "_execute_write_analysis_scripts.html" %}
-
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  const titleInput = document.querySelector("#query-title");
-  const urlInput = document.querySelector("#query-url-slug");
-  let urlEdited = Boolean(urlInput && urlInput.value);
-
-  function slugify(value) {
-    return value
-      .normalize("NFKD")
-      .replace(/[\u0300-\u036f]/g, "")
-      .toLowerCase()
-      .trim()
-      .replace(/[^a-z0-9_-]+/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "");
-  }
-
-  if (titleInput && urlInput) {
-    titleInput.addEventListener("input", () => {
-      if (!urlEdited) {
-        urlInput.value = slugify(titleInput.value);
-      }
-    });
-    urlInput.addEventListener("input", () => {
-      urlEdited = true;
-    });
-  }
-});
-</script>
-
-<script>
-window.addEventListener("DOMContentLoaded", () => {
-  const form = document.querySelector("form.sql.core");
-  const analysisSection = document.querySelector("#query-create-analysis-section");
-  const submitButton = form
-    ? form.querySelector("[data-query-create-submit]")
-    : null;
-  const analysisNote = form
-    ? form.querySelector("[data-query-create-analysis-note]")
-    : null;
-
-  function updateAnalysisNote(data) {
-    if (!analysisNote) {
-      return;
-    }
-    if (data.analysis_error) {
-      analysisNote.textContent = "This query cannot be saved until the SQL is valid.";
-    } else if (data.has_sql === false) {
-      analysisNote.textContent = "Enter SQL to analyze this query.";
-    } else if (data.analysis_is_write) {
-      analysisNote.textContent = "This query updates data in the database.";
-    } else {
-      analysisNote.textContent = "This is a read-only query.";
-    }
-  }
-
-  window.datasetteSqlParameters.setupSqlParameterRefresh({
-    form,
-    url: form.dataset.analyzeUrl,
-    renderParameters: false,
-    onData(data) {
-      window.datasetteSqlAnalysis.renderAnalysis(analysisSection, data);
-      if (submitButton) {
-        submitButton.disabled = data.save_disabled;
-      }
-      updateAnalysisNote(data);
-    },
-    onError(error) {
-      window.datasetteSqlAnalysis.renderAnalysis(analysisSection, {
-        analysis_error: error.message,
-        analysis_rows: [],
-      });
-      if (submitButton) {
-        submitButton.disabled = true;
-      }
-      updateAnalysisNote({ analysis_error: error.message });
-    },
-  });
-});
-</script>
-
-{% endblock %}

datasette/templates/query_list.html

@@ -1,281 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}{% if database %}{{ database }}: {% endif %}queries{% endblock %}
-
-{% block extra_head %}
-{{- super() -}}
-<style>
-.query-list-page {
-    max-width: 64rem;
-}
-.query-list-filters {
-    margin: 0.5rem 0 0.75rem;
-}
-.query-list-search {
-    align-items: center;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.45rem;
-    margin: 0 0 0.75rem;
-}
-.query-list-search label {
-    width: auto;
-}
-.query-list-search input[type=search] {
-    box-sizing: border-box;
-    flex: 1 1 18rem;
-    max-width: 24rem;
-}
-.query-list-search button[type=submit] {
-    font-size: 0.78rem;
-    height: 2rem;
-    line-height: 1.1;
-    padding: 0.35rem 0.65rem;
-}
-.query-list-facets {
-    align-items: flex-start;
-    display: flex;
-    flex-wrap: wrap;
-    gap: 1rem 1.6rem;
-    margin: 0 0 1rem;
-}
-.query-list-facet {
-    margin: 0;
-}
-.query-list-facet h2 {
-    font-size: 0.9rem;
-    line-height: 1.2;
-    margin: 0 0 0.35rem;
-}
-.query-list-facet ul {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.35rem;
-    margin: 0;
-    padding: 0;
-    list-style: none;
-}
-.query-list-facet-link,
-.query-list-facet-link:link,
-.query-list-facet-link:visited,
-.query-list-facet-link:hover,
-.query-list-facet-link:focus,
-.query-list-facet-link:active {
-    align-items: center;
-    border: 1px solid #c8d1dc;
-    border-radius: 0.25rem;
-    color: #39445a;
-    display: inline-flex;
-    font-size: 0.82rem;
-    gap: 0.4rem;
-    line-height: 1.1;
-    padding: 0.35rem 0.55rem;
-    text-decoration: none;
-}
-.query-list-facet-link:hover {
-    border-color: #7ca5c8;
-    color: #1f5d85;
-}
-.query-list-facet-link-active {
-    background-color: #edf6fb;
-    border-color: #6d9fc0;
-    font-weight: 700;
-}
-.query-list-facet-disabled {
-    color: #7b8794;
-    cursor: default;
-}
-.query-list-facet-count {
-    color: #4f5b6d;
-    font-variant-numeric: tabular-nums;
-}
-.query-list-results {
-    border-collapse: collapse;
-    font-size: 0.9rem;
-    margin: 0.25rem 0 1rem;
-    min-width: 42rem;
-    width: 100%;
-}
-.query-list-results th,
-.query-list-results td {
-    border-bottom: 1px solid #d7dde5;
-    padding: 0.45rem 0.7rem;
-    text-align: left;
-    vertical-align: top;
-}
-.query-list-results th {
-    background-color: #edf6fb;
-    border-top: 1px solid #d7dde5;
-    color: #39445a;
-    font-weight: 700;
-}
-.query-list-results tbody tr:nth-child(even) {
-    background-color: rgba(39, 104, 144, 0.05);
-}
-.query-list-results a.query-list-title {
-    font-weight: 700;
-}
-.query-list-description {
-    color: #4f5b6d;
-    font-size: 0.78rem;
-    margin: 0.15rem 0 0;
-}
-.query-list-owner {
-    color: #39445a;
-    font-family: var(--font-monospace, monospace);
-    white-space: nowrap;
-}
-.query-list-flags {
-    display: flex;
-    flex-wrap: wrap;
-    gap: 0.3rem;
-}
-.query-list-pill {
-    background-color: #eef1f5;
-    border: 1px solid #d7dde5;
-    border-radius: 0.25rem;
-    color: #39445a;
-    display: inline-block;
-    font-size: 0.75rem;
-    font-weight: 700;
-    line-height: 1;
-    padding: 0.25rem 0.4rem;
-    white-space: nowrap;
-}
-.query-list-pill-write {
-    background-color: #fff4db;
-    border-color: #e2b64e;
-}
-.query-list-pill-public {
-    background-color: #e7f5ec;
-    border-color: #9ecfab;
-    color: #267a3e;
-}
-.query-list-pill-private {
-    background-color: #f7edf0;
-    border-color: #dbb8c1;
-}
-.query-list-pill-trusted {
-    background-color: #e7f5ec;
-    border-color: #9ecfab;
-    color: #267a3e;
-}
-.query-list-empty {
-    color: #6b7280;
-}
-.query-list-footnotes {
-    border-top: 1px solid #d7dde5;
-    color: #4f5b6d;
-    font-size: 0.82rem;
-    margin: 0.35rem 0 1rem;
-    padding-top: 0.55rem;
-}
-.query-list-footnotes p {
-    margin: 0.25rem 0;
-}
-.query-list-footnotes .query-list-pill {
-    margin-right: 0.35rem;
-}
-.query-list-pagination a {
-    border: 1px solid #007bff;
-    border-radius: 0.25rem;
-    display: inline-block;
-    padding: 0.45rem 0.7rem;
-}
-.query-list-pagination-bottom {
-    margin-top: 0.75rem;
-}
-@media (max-width: 700px) {
-    .query-list-search input[type=search] {
-        max-width: none;
-    }
-}
-</style>
-{% endblock %}
-
-{% block body_class %}query-list{% if database %} db-{{ database|to_css_class }}{% endif %}{% endblock %}
-
-{% block crumbs %}
-{{ crumbs.nav(request=request, database=database) }}
-{% endblock %}
-
-{% block content %}
-
-<div class="query-list-page">
-
-<h1 style="padding-left: 10px; border-left: 10px solid #{% if database_color %}{{ database_color }}{% else %}666{% endif %}">Queries</h1>
-
-<form class="query-list-filters core" action="{{ query_list_path }}" method="get">
-    <p class="query-list-search">
-        <label for="query-search">Search</label>
-        <input id="query-search" type="search" name="q" value="{{ filters.q }}">
-        {% if filters.is_write %}<input type="hidden" name="is_write" value="{{ filters.is_write }}">{% endif %}
-        {% if filters.is_private %}<input type="hidden" name="is_private" value="{{ filters.is_private }}">{% endif %}
-        {% if filters.source %}<input type="hidden" name="source" value="{{ filters.source }}">{% endif %}
-        {% if filters.owner_id %}<input type="hidden" name="owner_id" value="{{ filters.owner_id }}">{% endif %}
-        <button type="submit">Search</button>
-    </p>
-</form>
-
-<nav class="query-list-facets" aria-label="Query filters">
-    {% for facet in facets %}
-        <section class="query-list-facet">
-            <h2>{{ facet.title }}</h2>
-            <ul>
-                {% for item in facet["items"] %}
-                    <li>{% if item.href %}<a class="query-list-facet-link{% if item.active %} query-list-facet-link-active{% endif %}" href="{{ item.href }}"{% if item.active %} aria-current="true"{% endif %}>{% else %}<span class="query-list-facet-link query-list-facet-disabled">{% endif %}<span>{{ item.label }}</span><span class="query-list-facet-count">{{ item.count }}</span>{% if item.href %}</a>{% else %}</span>{% endif %}</li>
-                {% endfor %}
-            </ul>
-        </section>
-    {% endfor %}
-</nav>
-
-{% if queries %}
-    <div class="table-wrapper"><table class="query-list-results">
-        <thead>
-            <tr>
-                {% if show_database %}<th scope="col">Database</th>{% endif %}
-                <th scope="col">Query</th>
-                <th scope="col">Owner</th>
-                <th scope="col">Flags</th>
-            </tr>
-        </thead>
-        <tbody>
-            {% for query in queries %}
-                <tr>
-                    {% if show_database %}
-                        <td><a class="query-list-database" href="{{ urls.database(query.database) }}">{{ query.database }}</a></td>
-                    {% endif %}
-                    <td>
-                        <a class="query-list-title" href="{{ urls.query(query.database, query.name) }}{% if query.fragment %}#{{ query.fragment }}{% endif %}" title="{{ query.description or query.sql }}">{{ query.title or query.name }}</a>{% if query.private %} 🔒{% endif %}
-                        {% if query.description %}<p class="query-list-description">{{ query.description }}</p>{% endif %}
-                    </td>
-                    <td class="query-list-owner">{% if query.owner_id is not none %}{{ query.owner_id }}{% else %}<span class="query-list-empty">-</span>{% endif %}</td>
-                    <td>
-                        <span class="query-list-flags">
-                            {% if query.is_write %}<span class="query-list-pill query-list-pill-write">Writable</span>{% else %}<span class="query-list-pill">Read-only</span>{% endif %}
-                            {% if query.is_private %}<span class="query-list-pill query-list-pill-private">Private</span>{% endif %}
-                            {% if query.is_trusted %}<span class="query-list-pill query-list-pill-trusted">Trusted</span>{% endif %}
-                        </span>
-                    </td>
-                </tr>
-            {% endfor %}
-        </tbody>
-    </table></div>
-    {% if show_private_note or show_trusted_note %}
-        <div class="query-list-footnotes">
-            {% if show_private_note %}<p><span class="query-list-pill query-list-pill-private">Private</span>Only the owning actor can view this query.</p>{% endif %}
-            {% if show_trusted_note %}<p><span class="query-list-pill query-list-pill-trusted">Trusted</span>Execution skips the usual SQL and write permission checks after view-query allows access.</p>{% endif %}
-        </div>
-    {% endif %}
-{% else %}
-    <p>No queries found.</p>
-{% endif %}
-
-{% if next_url %}
-    <nav class="query-list-pagination query-list-pagination-bottom" aria-label="Query pagination"><a href="{{ next_url }}">Next page</a></nav>
-{% endif %}
-
-</div>
-
-{% endblock %}

datasette/templates/schema.html

@@ -1,41 +0,0 @@
-{% extends "base.html" %}
-
-{% block title %}{% if is_instance %}Schema for all databases{% elif table_name %}Schema for {{ schemas[0].database }}.{{ table_name }}{% else %}Schema for {{ schemas[0].database }}{% endif %}{% endblock %}
-
-{% block body_class %}schema{% endblock %}
-
-{% block crumbs %}
-{% if is_instance %}
-{{ crumbs.nav(request=request) }}
-{% elif table_name %}
-{{ crumbs.nav(request=request, database=schemas[0].database, table=table_name) }}
-{% else %}
-{{ crumbs.nav(request=request, database=schemas[0].database) }}
-{% endif %}
-{% endblock %}
-
-{% block content %}
-<div class="page-header">
-    <h1>{% if is_instance %}Schema for all databases{% elif table_name %}Schema for {{ table_name }}{% else %}Schema for {{ schemas[0].database }}{% endif %}</h1>
-</div>
-
-{% for item in schemas %}
-    {% if is_instance %}
-        <h2>{{ item.database }}</h2>
-    {% endif %}
-
-    {% if item.schema %}
-        <pre style="background-color: #f5f5f5; padding: 1em; overflow-x: auto; border: 1px solid #ddd; border-radius: 4px;"><code>{{ item.schema }}</code></pre>
-    {% else %}
-        <p><em>No schema available for this database.</em></p>
-    {% endif %}
-
-    {% if not loop.last %}
-        <hr style="margin: 2em 0;">
-    {% endif %}
-{% endfor %}
-
-{% if not schemas %}
-    <p><em>No databases with viewable schemas found.</em></p>
-{% endif %}
-{% endblock %}

datasette/templates/table.html

@@ -4,9 +4,7 @@
 
 {% block extra_head %}
 {{- super() -}}
-<script src="{{ urls.static('column-chooser.js') }}" defer></script>
 <script src="{{ urls.static('table.js') }}" defer></script>
-<script src="{{ urls.static('mobile-column-actions.js') }}" defer></script>
 <script>DATASETTE_ALLOW_FACET = {{ datasette_allow_facet }};</script>
 <style>
 @media only screen and (max-width: 576px) {
@@ -138,26 +136,6 @@
     {% include "_facet_results.html" %}
 {% endif %}
 
-{% if all_columns %}
-<column-chooser></column-chooser>
-<button class="choose-columns-mobile small-screen-only" onclick="openColumnChooser()">Choose columns</button>
-<button type="button" class="column-actions-mobile small-screen-only">
-    <svg aria-hidden="true" xmlns="http://www.w3.org/2000/svg" width="14" height="14" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
-        <circle cx="12" cy="12" r="3"></circle>
-        <path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z"></path>
-    </svg>
-    <span>Column actions</span>
-</button>
-<script>
-window._columnChooserData = {{ {"allColumns": all_columns, "selectedColumns": display_columns|map(attribute='name')|list, "primaryKeys": primary_keys}|tojson }};
-</script>
-{% endif %}
-{% if set_column_type_ui %}
-<script>
-window._setColumnTypeData = {{ set_column_type_ui|tojson }};
-</script>
-{% endif %}
-
 {% include custom_table_templates %}
 
 {% if next_url %}

datasette/tokens.py

@@ -1,193 +0,0 @@
-"""
-Token handler system for Datasette.
-
-Provides a base class for token handlers and the default signed token handler.
-Plugins can implement register_token_handler to provide custom token backends
-(e.g. database-backed tokens that can be revoked and audited).
-"""
-
-from __future__ import annotations
-
-import dataclasses
-import time
-from typing import TYPE_CHECKING, Optional
-
-import itsdangerous
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-
-@dataclasses.dataclass
-class TokenRestrictions:
-    """
-    Restrictions to apply to a token, limiting which actions it can perform.
-
-    Use the builder methods to construct restrictions::
-
-        restrictions = (TokenRestrictions()
-            .allow_all("view-instance")
-            .allow_database("mydb", "create-table")
-            .allow_resource("mydb", "mytable", "insert-row"))
-    """
-
-    all: list[str] = dataclasses.field(default_factory=list)
-    database: dict[str, list[str]] = dataclasses.field(default_factory=dict)
-    resource: dict[str, dict[str, list[str]]] = dataclasses.field(default_factory=dict)
-
-    def allow_all(self, action: str) -> "TokenRestrictions":
-        """Allow an action across all databases and resources."""
-        self.all.append(action)
-        return self
-
-    def allow_database(self, database: str, action: str) -> "TokenRestrictions":
-        """Allow an action on a specific database."""
-        self.database.setdefault(database, []).append(action)
-        return self
-
-    def allow_resource(
-        self, database: str, resource: str, action: str
-    ) -> "TokenRestrictions":
-        """Allow an action on a specific resource within a database."""
-        self.resource.setdefault(database, {}).setdefault(resource, []).append(action)
-        return self
-
-    def abbreviated(self, datasette: "Datasette") -> Optional[dict]:
-        """
-        Return the abbreviated ``_r`` dictionary shape for this set of
-        restrictions, using action abbreviations registered with ``datasette``.
-        Returns ``None`` if no restrictions are set.
-        """
-        if not (self.all or self.database or self.resource):
-            return None
-
-        def abbreviate_action(action):
-            action_obj = datasette.actions.get(action)
-            if not action_obj:
-                return action
-            return action_obj.abbr or action
-
-        result: dict = {}
-        if self.all:
-            result["a"] = [abbreviate_action(a) for a in self.all]
-        if self.database:
-            result["d"] = {
-                database: [abbreviate_action(a) for a in actions]
-                for database, actions in self.database.items()
-            }
-        if self.resource:
-            result["r"] = {}
-            for database, resources in self.resource.items():
-                for resource, actions in resources.items():
-                    result["r"].setdefault(database, {})[resource] = [
-                        abbreviate_action(a) for a in actions
-                    ]
-        return result
-
-
-class TokenHandler:
-    """
-    Base class for token handlers.
-
-    Subclass this and implement create_token() and verify_token() to provide
-    a custom token backend. Return an instance from the register_token_handler hook.
-    """
-
-    name: str = ""
-
-    async def create_token(
-        self,
-        datasette: "Datasette",
-        actor_id: str,
-        *,
-        expires_after: Optional[int] = None,
-        restrictions: Optional[TokenRestrictions] = None,
-    ) -> str:
-        """Create and return a token string for the given actor."""
-        raise NotImplementedError
-
-    async def verify_token(self, datasette: "Datasette", token: str) -> Optional[dict]:
-        """
-        Verify a token and return an actor dict, or None if this handler
-        does not recognize the token.
-        """
-        raise NotImplementedError
-
-
-class SignedTokenHandler(TokenHandler):
-    """
-    Default token handler using itsdangerous signed tokens (dstok_ prefix).
-    """
-
-    name = "signed"
-
-    async def create_token(
-        self,
-        datasette: "Datasette",
-        actor_id: str,
-        *,
-        expires_after: Optional[int] = None,
-        restrictions: Optional[TokenRestrictions] = None,
-    ) -> str:
-        if not datasette.setting("allow_signed_tokens"):
-            raise ValueError(
-                "Signed tokens are not enabled for this Datasette instance"
-            )
-
-        token = {"a": actor_id, "t": int(time.time())}
-
-        if expires_after:
-            token["d"] = expires_after
-        if restrictions is not None:
-            abbreviated = restrictions.abbreviated(datasette)
-            if abbreviated is not None:
-                token["_r"] = abbreviated
-        return "dstok_{}".format(datasette.sign(token, namespace="token"))
-
-    async def verify_token(self, datasette: "Datasette", token: str) -> Optional[dict]:
-        prefix = "dstok_"
-
-        if not datasette.setting("allow_signed_tokens"):
-            return None
-
-        max_signed_tokens_ttl = datasette.setting("max_signed_tokens_ttl")
-
-        if not token.startswith(prefix):
-            return None
-
-        raw = token[len(prefix) :]
-        try:
-            decoded = datasette.unsign(raw, namespace="token")
-        except itsdangerous.BadSignature:
-            return None
-
-        if "t" not in decoded:
-            return None
-        created = decoded["t"]
-        if not isinstance(created, int):
-            return None
-
-        duration = decoded.get("d")
-        if duration is not None and not isinstance(duration, int):
-            return None
-
-        if (duration is None and max_signed_tokens_ttl) or (
-            duration is not None
-            and max_signed_tokens_ttl
-            and duration > max_signed_tokens_ttl
-        ):
-            duration = max_signed_tokens_ttl
-
-        if duration:
-            if time.time() - created > duration:
-                return None
-
-        actor = {"id": decoded["a"], "token": "dstok"}
-
-        if "_r" in decoded:
-            actor["_r"] = decoded["_r"]
-
-        if duration:
-            actor["token_expires"] = created + duration
-
-        return actor

datasette/utils/__init__.py

@@ -4,7 +4,6 @@ import aiofiles
 import click
 from collections import OrderedDict, namedtuple, Counter
 import copy
-import dataclasses
 import base64
 import hashlib
 import inspect
@@ -28,58 +27,6 @@ from .sqlite import sqlite3, supports_table_xinfo
 
 if typing.TYPE_CHECKING:
     from datasette.database import Database
-    from datasette.permissions import Resource
-
-
-@dataclasses.dataclass
-class PaginatedResources:
-    """Paginated results from allowed_resources query."""
-
-    resources: List["Resource"]
-    next: str | None  # Keyset token for next page (None if no more results)
-    _datasette: typing.Any = dataclasses.field(default=None, repr=False)
-    _action: str = dataclasses.field(default=None, repr=False)
-    _actor: typing.Any = dataclasses.field(default=None, repr=False)
-    _parent: str | None = dataclasses.field(default=None, repr=False)
-    _include_is_private: bool = dataclasses.field(default=False, repr=False)
-    _include_reasons: bool = dataclasses.field(default=False, repr=False)
-    _limit: int = dataclasses.field(default=100, repr=False)
-
-    async def all(self):
-        """
-        Async generator that yields all resources across all pages.
-
-        Automatically handles pagination under the hood. This is useful when you need
-        to iterate through all results without manually managing pagination tokens.
-
-        Yields:
-            Resource objects one at a time
-
-        Example:
-            page = await datasette.allowed_resources("view-table", actor)
-            async for table in page.all():
-                print(f"{table.parent}/{table.child}")
-        """
-        # Yield all resources from current page
-        for resource in self.resources:
-            yield resource
-
-        # Continue fetching subsequent pages if there are more
-        next_token = self.next
-        while next_token:
-            page = await self._datasette.allowed_resources(
-                self._action,
-                self._actor,
-                parent=self._parent,
-                include_is_private=self._include_is_private,
-                include_reasons=self._include_reasons,
-                limit=self._limit,
-                next=next_token,
-            )
-            for resource in page.resources:
-                yield resource
-            next_token = page.next
-
 
 # From https://www.sqlite.org/lang_keywords.html
 reserved_words = set(
@@ -155,15 +102,9 @@ Column = namedtuple(
 functions_marked_as_documented = []
 
 
-def documented(fn=None, *, label=None):
-    def decorate(fn):
-        fn._datasette_docs_label = label or "internals_utils_{}".format(fn.__name__)
-        functions_marked_as_documented.append(fn)
-        return fn
-
-    if fn is None:
-        return decorate
-    return decorate(fn)
+def documented(fn):
+    functions_marked_as_documented.append(fn)
+    return fn
 
 
 @documented
@@ -471,7 +412,7 @@ def make_dockerfile(
             "/usr/lib/x86_64-linux-gnu/mod_spatialite.so"
         )
     return """
-FROM python:3.11.0-slim-bullseye
+FROM python:3.14-slim-trixie
 COPY . /app
 WORKDIR /app
 {apt_get_extras}
@@ -618,10 +559,7 @@ def get_outbound_foreign_keys(conn, table):
 
 def get_all_foreign_keys(conn):
     tables = [
-        r[0]
-        for r in conn.execute(
-            'select name from sqlite_master where type="table" order by name'
-        )
+        r[0] for r in conn.execute('select name from sqlite_master where type="table"')
     ]
     table_to_foreign_keys = {}
     for table in tables:
@@ -643,15 +581,6 @@ def get_all_foreign_keys(conn):
                 {"other_table": table_name, "column": from_, "other_column": to_}
             )
 
-    # Sort foreign keys for deterministic ordering
-    for table in table_to_foreign_keys:
-        table_to_foreign_keys[table]["incoming"].sort(
-            key=lambda fk: (fk["other_table"], fk["column"], fk["other_column"])
-        )
-        table_to_foreign_keys[table]["outgoing"].sort(
-            key=lambda fk: (fk["other_table"], fk["column"], fk["other_column"])
-        )
-
     return table_to_foreign_keys
 
 
@@ -683,22 +612,19 @@ def detect_fts_sql(table):
                     and sql like '%VIRTUAL TABLE%USING FTS%'
                 )
             )
-    """.format(table=table.replace("'", "''"))
+    """.format(
+        table=table.replace("'", "''")
+    )
 
 
 def detect_json1(conn=None):
-    close_conn = False
     if conn is None:
         conn = sqlite3.connect(":memory:")
-        close_conn = True
     try:
         conn.execute("SELECT json('{}')")
         return True
     except Exception:
         return False
-    finally:
-        if close_conn:
-            conn.close()
 
 
 def table_columns(conn, table):
@@ -715,11 +641,8 @@ def table_column_details(conn, table):
             ).fetchall()
         ]
     else:
-        # First trigger a query against sqlite_master to fix an intermittent
-        # test failure, see https://github.com/simonw/datasette/issues/2632
-        conn.execute("select 1 from sqlite_master limit 1").fetchall()
+        # Treat hidden as 0 for all columns
         return [
-            # Treat hidden as 0 for all columns.
             Column(*(list(r) + [0]))
             for r in conn.execute(
                 f"PRAGMA table_info({escape_sqlite(table)});"
@@ -913,26 +836,18 @@ _infinities = {float("inf"), float("-inf")}
 
 
 def remove_infinites(row):
-    """
-    Replace float('inf') and float('-inf') with None in a row.
-
-    Returns the original row object unchanged if no infinities are found.
-    """
+    to_check = row
     if isinstance(row, dict):
-        for v in row.values():
-            if isinstance(v, float) and v in _infinities:
-                return {
-                    k: (None if isinstance(v2, float) and v2 in _infinities else v2)
-                    for k, v2 in row.items()
-                }
+        to_check = row.values()
+    if not any((c in _infinities) if isinstance(c, float) else 0 for c in to_check):
+        return row
+    if isinstance(row, dict):
+        return {
+            k: (None if (isinstance(v, float) and v in _infinities) else v)
+            for k, v in row.items()
+        }
     else:
-        for v in row:
-            if isinstance(v, float) and v in _infinities:
-                return [
-                    None if isinstance(v2, float) and v2 in _infinities else v2
-                    for v2 in row
-                ]
-    return row
+        return [None if (isinstance(c, float) and c in _infinities) else c for c in row]
 
 
 class StaticMount(click.ParamType):
@@ -1097,35 +1012,12 @@ def _gather_arguments(fn, kwargs):
     return call_with
 
 
-@documented
 def call_with_supported_arguments(fn, **kwargs):
-    """
-    Call ``fn`` with the subset of ``**kwargs`` matching its signature.
-
-    This implements dependency injection: the caller provides all available
-    keyword arguments and the function receives only the ones it declares
-    as parameters.
-
-    :param fn: A callable (sync function)
-    :param kwargs: All available keyword arguments
-    :returns: The return value of ``fn``
-    """
     call_with = _gather_arguments(fn, kwargs)
     return fn(*call_with)
 
 
-@documented
 async def async_call_with_supported_arguments(fn, **kwargs):
-    """
-    Async version of :func:`call_with_supported_arguments`.
-
-    Calls ``await fn(...)`` with the subset of ``**kwargs`` matching its
-    signature.
-
-    :param fn: An async callable
-    :param kwargs: All available keyword arguments
-    :returns: The return value of ``await fn(...)``
-    """
     call_with = _gather_arguments(fn, kwargs)
     return await fn(*call_with)
 

datasette/utils/actions_sql.py

@@ -1,591 +0,0 @@
-"""
-SQL query builder for hierarchical permission checking.
-
-This module implements a cascading permission system based on the pattern
-from https://github.com/simonw/research/tree/main/sqlite-permissions-poc
-
-It builds SQL queries that:
-
-1. Start with all resources of a given type (from resource_type.resources_sql())
-2. Gather permission rules from plugins (via permission_resources_sql hook)
-3. Apply cascading logic: child → parent → global
-4. Apply DENY-beats-ALLOW at each level
-
-The core pattern is:
-- Resources are identified by (parent, child) tuples
-- Rules are evaluated at three levels:
-  - child: exact match on (parent, child)
-  - parent: match on (parent, NULL)
-  - global: match on (NULL, NULL)
-- At the same level, DENY (allow=0) beats ALLOW (allow=1)
-- Across levels, child beats parent beats global
-"""
-
-from typing import TYPE_CHECKING
-
-from datasette.utils.permissions import gather_permission_sql_from_hooks
-
-if TYPE_CHECKING:
-    from datasette.app import Datasette
-
-
-async def build_allowed_resources_sql(
-    datasette: "Datasette",
-    actor: dict | None,
-    action: str,
-    *,
-    parent: str | None = None,
-    include_is_private: bool = False,
-) -> tuple[str, dict]:
-    """
-    Build a SQL query that returns all resources the actor can access for this action.
-
-    Args:
-        datasette: The Datasette instance
-        actor: The actor dict (or None for unauthenticated)
-        action: The action name (e.g., "view-table", "view-database")
-        parent: Optional parent filter to limit results (e.g., database name)
-        include_is_private: If True, add is_private column showing if anonymous cannot access
-
-    Returns:
-        A tuple of (sql_query, params_dict)
-
-    The returned SQL query will have three columns (or four with include_is_private):
-        - parent: The parent resource identifier (or NULL)
-        - child: The child resource identifier (or NULL)
-        - reason: The reason from the rule that granted access
-        - is_private: (if include_is_private) 1 if anonymous cannot access, 0 otherwise
-
-    Example:
-        For action="view-table", this might return:
-        SELECT parent, child, reason FROM ... WHERE is_allowed = 1
-
-        Results would be like:
-        ('analytics', 'users', 'role-based: analysts can access analytics DB')
-        ('analytics', 'events', 'role-based: analysts can access analytics DB')
-        ('production', 'orders', 'business-exception: allow production.orders for carol')
-    """
-    # Get the Action object
-    action_obj = datasette.actions.get(action)
-    if not action_obj:
-        raise ValueError(f"Unknown action: {action}")
-
-    # If this action also_requires another action, we need to combine the queries
-    if action_obj.also_requires:
-        # Build both queries
-        main_sql, main_params = await _build_single_action_sql(
-            datasette,
-            actor,
-            action,
-            parent=parent,
-            include_is_private=include_is_private,
-        )
-        required_sql, required_params = await _build_single_action_sql(
-            datasette,
-            actor,
-            action_obj.also_requires,
-            parent=parent,
-            include_is_private=False,
-        )
-
-        # Merge parameters - they should have identical values for :actor, :actor_id, etc.
-        all_params = {**main_params, **required_params}
-        if parent is not None:
-            all_params["filter_parent"] = parent
-
-        # Combine with INNER JOIN - only resources allowed by both actions
-        combined_sql = f"""
-WITH
-main_allowed AS (
-{main_sql}
-),
-required_allowed AS (
-{required_sql}
-)
-SELECT m.parent, m.child, m.reason"""
-
-        if include_is_private:
-            combined_sql += ", m.is_private"
-
-        combined_sql += """
-FROM main_allowed m
-INNER JOIN required_allowed r
-  ON ((m.parent = r.parent) OR (m.parent IS NULL AND r.parent IS NULL))
- AND ((m.child = r.child) OR (m.child IS NULL AND r.child IS NULL))
-"""
-
-        if parent is not None:
-            combined_sql += "WHERE m.parent = :filter_parent\n"
-
-        combined_sql += "ORDER BY m.parent, m.child"
-
-        return combined_sql, all_params
-
-    # No also_requires, build single action query
-    return await _build_single_action_sql(
-        datasette, actor, action, parent=parent, include_is_private=include_is_private
-    )
-
-
-async def _build_single_action_sql(
-    datasette: "Datasette",
-    actor: dict | None,
-    action: str,
-    *,
-    parent: str | None = None,
-    include_is_private: bool = False,
-) -> tuple[str, dict]:
-    """
-    Build SQL for a single action (internal helper for build_allowed_resources_sql).
-
-    This contains the original logic from build_allowed_resources_sql, extracted
-    to allow combining multiple actions when also_requires is used.
-    """
-    # Get the Action object
-    action_obj = datasette.actions.get(action)
-    if not action_obj:
-        raise ValueError(f"Unknown action: {action}")
-
-    # Get base resources SQL from the resource class
-    base_resources_sql = await action_obj.resource_class.resources_sql(
-        datasette, actor=actor
-    )
-
-    permission_sqls = await gather_permission_sql_from_hooks(
-        datasette=datasette,
-        actor=actor,
-        action=action,
-    )
-
-    # If permission_sqls is the sentinel, skip all permission checks
-    # Return SQL that allows all resources
-    from datasette.utils.permissions import SKIP_PERMISSION_CHECKS
-
-    if permission_sqls is SKIP_PERMISSION_CHECKS:
-        cols = "parent, child, 'skip_permission_checks' AS reason"
-        if include_is_private:
-            cols += ", 0 AS is_private"
-        return f"SELECT {cols} FROM ({base_resources_sql})", {}
-
-    all_params = {}
-    rule_sqls = []
-    restriction_sqls = []
-
-    for permission_sql in permission_sqls:
-        # Always collect params (even from restriction-only plugins)
-        all_params.update(permission_sql.params or {})
-
-        # Collect restriction SQL filters
-        if permission_sql.restriction_sql:
-            restriction_sqls.append(permission_sql.restriction_sql)
-
-        # Skip plugins that only provide restriction_sql (no permission rules)
-        if permission_sql.sql is None:
-            continue
-        rule_sqls.append(f"""
-            SELECT parent, child, allow, reason, '{permission_sql.source}' AS source_plugin FROM (
-                {permission_sql.sql}
-            )
-            """.strip())
-
-    # If no rules, return empty result (deny all)
-    if not rule_sqls:
-        empty_cols = "NULL AS parent, NULL AS child, NULL AS reason"
-        if include_is_private:
-            empty_cols += ", NULL AS is_private"
-        return f"SELECT {empty_cols} WHERE 0", {}
-
-    # Build the cascading permission query
-    rules_union = " UNION ALL ".join(rule_sqls)
-
-    # Build the main query
-    query_parts = [
-        "WITH",
-        "base AS (",
-        f"  {base_resources_sql}",
-        "),",
-        "all_rules AS (",
-        f"  {rules_union}",
-        "),",
-    ]
-
-    # If include_is_private, we need to build anonymous permissions too
-    if include_is_private:
-        anon_permission_sqls = await gather_permission_sql_from_hooks(
-            datasette=datasette,
-            actor=None,
-            action=action,
-        )
-        anon_sqls_rewritten = []
-        anon_params = {}
-
-        for permission_sql in anon_permission_sqls:
-            # Skip plugins that only provide restriction_sql (no permission rules)
-            if permission_sql.sql is None:
-                continue
-            rewritten_sql = permission_sql.sql
-            for key, value in (permission_sql.params or {}).items():
-                anon_key = f"anon_{key}"
-                anon_params[anon_key] = value
-                rewritten_sql = rewritten_sql.replace(f":{key}", f":{anon_key}")
-            anon_sqls_rewritten.append(rewritten_sql)
-
-        all_params.update(anon_params)
-
-        if anon_sqls_rewritten:
-            anon_rules_union = " UNION ALL ".join(anon_sqls_rewritten)
-            query_parts.extend(
-                [
-                    "anon_rules AS (",
-                    f"  {anon_rules_union}",
-                    "),",
-                ]
-            )
-        else:
-            query_parts.extend(
-                [
-                    "anon_rules AS (",
-                    "  SELECT NULL AS parent, NULL AS child, 0 AS allow, NULL AS reason WHERE 0",
-                    "),",
-                ]
-            )
-
-    # Continue with the cascading logic
-    query_parts.extend(
-        [
-            "child_lvl AS (",
-            "  SELECT b.parent, b.child,",
-            "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-            "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow,",
-            "         json_group_array(CASE WHEN ar.allow = 0 THEN ar.source_plugin || ': ' || ar.reason END) AS deny_reasons,",
-            "         json_group_array(CASE WHEN ar.allow = 1 THEN ar.source_plugin || ': ' || ar.reason END) AS allow_reasons",
-            "  FROM base b",
-            "  LEFT JOIN all_rules ar ON ar.parent = b.parent AND ar.child = b.child",
-            "  GROUP BY b.parent, b.child",
-            "),",
-            "parent_lvl AS (",
-            "  SELECT b.parent, b.child,",
-            "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-            "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow,",
-            "         json_group_array(CASE WHEN ar.allow = 0 THEN ar.source_plugin || ': ' || ar.reason END) AS deny_reasons,",
-            "         json_group_array(CASE WHEN ar.allow = 1 THEN ar.source_plugin || ': ' || ar.reason END) AS allow_reasons",
-            "  FROM base b",
-            "  LEFT JOIN all_rules ar ON ar.parent = b.parent AND ar.child IS NULL",
-            "  GROUP BY b.parent, b.child",
-            "),",
-            "global_lvl AS (",
-            "  SELECT b.parent, b.child,",
-            "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-            "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow,",
-            "         json_group_array(CASE WHEN ar.allow = 0 THEN ar.source_plugin || ': ' || ar.reason END) AS deny_reasons,",
-            "         json_group_array(CASE WHEN ar.allow = 1 THEN ar.source_plugin || ': ' || ar.reason END) AS allow_reasons",
-            "  FROM base b",
-            "  LEFT JOIN all_rules ar ON ar.parent IS NULL AND ar.child IS NULL",
-            "  GROUP BY b.parent, b.child",
-            "),",
-        ]
-    )
-
-    # Add anonymous decision logic if needed
-    if include_is_private:
-        query_parts.extend(
-            [
-                "anon_child_lvl AS (",
-                "  SELECT b.parent, b.child,",
-                "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-                "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow",
-                "  FROM base b",
-                "  LEFT JOIN anon_rules ar ON ar.parent = b.parent AND ar.child = b.child",
-                "  GROUP BY b.parent, b.child",
-                "),",
-                "anon_parent_lvl AS (",
-                "  SELECT b.parent, b.child,",
-                "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-                "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow",
-                "  FROM base b",
-                "  LEFT JOIN anon_rules ar ON ar.parent = b.parent AND ar.child IS NULL",
-                "  GROUP BY b.parent, b.child",
-                "),",
-                "anon_global_lvl AS (",
-                "  SELECT b.parent, b.child,",
-                "         MAX(CASE WHEN ar.allow = 0 THEN 1 ELSE 0 END) AS any_deny,",
-                "         MAX(CASE WHEN ar.allow = 1 THEN 1 ELSE 0 END) AS any_allow",
-                "  FROM base b",
-                "  LEFT JOIN anon_rules ar ON ar.parent IS NULL AND ar.child IS NULL",
-                "  GROUP BY b.parent, b.child",
-                "),",
-                "anon_decisions AS (",
-                "  SELECT",
-                "    b.parent, b.child,",
-                "    CASE",
-                "      WHEN acl.any_deny = 1 THEN 0",
-                "      WHEN acl.any_allow = 1 THEN 1",
-                "      WHEN apl.any_deny = 1 THEN 0",
-                "      WHEN apl.any_allow = 1 THEN 1",
-                "      WHEN agl.any_deny = 1 THEN 0",
-                "      WHEN agl.any_allow = 1 THEN 1",
-                "      ELSE 0",
-                "    END AS anon_is_allowed",
-                "  FROM base b",
-                "  JOIN anon_child_lvl acl ON b.parent = acl.parent AND (b.child = acl.child OR (b.child IS NULL AND acl.child IS NULL))",
-                "  JOIN anon_parent_lvl apl ON b.parent = apl.parent AND (b.child = apl.child OR (b.child IS NULL AND apl.child IS NULL))",
-                "  JOIN anon_global_lvl agl ON b.parent = agl.parent AND (b.child = agl.child OR (b.child IS NULL AND agl.child IS NULL))",
-                "),",
-            ]
-        )
-
-    # Final decisions
-    query_parts.extend(
-        [
-            "decisions AS (",
-            "  SELECT",
-            "    b.parent, b.child,",
-            "    -- Cascading permission logic: child → parent → global, DENY beats ALLOW at each level",
-            "    -- Priority order:",
-            "    --   1. Child-level deny (most specific, blocks access)",
-            "    --   2. Child-level allow (most specific, grants access)",
-            "    --   3. Parent-level deny (intermediate, blocks access)",
-            "    --   4. Parent-level allow (intermediate, grants access)",
-            "    --   5. Global-level deny (least specific, blocks access)",
-            "    --   6. Global-level allow (least specific, grants access)",
-            "    --   7. Default deny (no rules match)",
-            "    CASE",
-            "      WHEN cl.any_deny = 1 THEN 0",
-            "      WHEN cl.any_allow = 1 THEN 1",
-            "      WHEN pl.any_deny = 1 THEN 0",
-            "      WHEN pl.any_allow = 1 THEN 1",
-            "      WHEN gl.any_deny = 1 THEN 0",
-            "      WHEN gl.any_allow = 1 THEN 1",
-            "      ELSE 0",
-            "    END AS is_allowed,",
-            "    CASE",
-            "      WHEN cl.any_deny = 1 THEN cl.deny_reasons",
-            "      WHEN cl.any_allow = 1 THEN cl.allow_reasons",
-            "      WHEN pl.any_deny = 1 THEN pl.deny_reasons",
-            "      WHEN pl.any_allow = 1 THEN pl.allow_reasons",
-            "      WHEN gl.any_deny = 1 THEN gl.deny_reasons",
-            "      WHEN gl.any_allow = 1 THEN gl.allow_reasons",
-            "      ELSE '[]'",
-            "    END AS reason",
-        ]
-    )
-
-    if include_is_private:
-        query_parts.append(
-            "    , CASE WHEN ad.anon_is_allowed = 0 THEN 1 ELSE 0 END AS is_private"
-        )
-
-    query_parts.extend(
-        [
-            "  FROM base b",
-            "  JOIN child_lvl cl ON b.parent = cl.parent AND (b.child = cl.child OR (b.child IS NULL AND cl.child IS NULL))",
-            "  JOIN parent_lvl pl ON b.parent = pl.parent AND (b.child = pl.child OR (b.child IS NULL AND pl.child IS NULL))",
-            "  JOIN global_lvl gl ON b.parent = gl.parent AND (b.child = gl.child OR (b.child IS NULL AND gl.child IS NULL))",
-        ]
-    )
-
-    if include_is_private:
-        query_parts.append(
-            "  JOIN anon_decisions ad ON b.parent = ad.parent AND (b.child = ad.child OR (b.child IS NULL AND ad.child IS NULL))"
-        )
-
-    query_parts.append(")")
-
-    # Add restriction list CTE if there are restrictions
-    if restriction_sqls:
-        # Wrap each restriction_sql in a subquery to avoid operator precedence issues
-        # with UNION ALL inside the restriction SQL statements
-        restriction_intersect = "\nINTERSECT\n".join(
-            f"SELECT * FROM ({sql})" for sql in restriction_sqls
-        )
-        query_parts.extend(
-            [",", "restriction_list AS (", f"  {restriction_intersect}", ")"]
-        )
-
-    # Final SELECT
-    select_cols = "parent, child, reason"
-    if include_is_private:
-        select_cols += ", is_private"
-
-    query_parts.append(f"SELECT {select_cols}")
-    query_parts.append("FROM decisions")
-    query_parts.append("WHERE is_allowed = 1")
-
-    # Add restriction filter if there are restrictions
-    if restriction_sqls:
-        query_parts.append("""
-  AND EXISTS (
-    SELECT 1 FROM restriction_list r
-    WHERE (r.parent = decisions.parent OR r.parent IS NULL)
-      AND (r.child = decisions.child OR r.child IS NULL)
-  )""")
-
-    # Add parent filter if specified
-    if parent is not None:
-        query_parts.append("  AND parent = :filter_parent")
-        all_params["filter_parent"] = parent
-
-    query_parts.append("ORDER BY parent, child")
-
-    query = "\n".join(query_parts)
-    return query, all_params
-
-
-async def build_permission_rules_sql(
-    datasette: "Datasette", actor: dict | None, action: str
-) -> tuple[str, dict]:
-    """
-    Build the UNION SQL and params for all permission rules for a given actor and action.
-
-    Returns:
-        A tuple of (sql, params) where sql is a UNION ALL query that returns
-        (parent, child, allow, reason, source_plugin) rows.
-    """
-    # Get the Action object
-    action_obj = datasette.actions.get(action)
-    if not action_obj:
-        raise ValueError(f"Unknown action: {action}")
-
-    permission_sqls = await gather_permission_sql_from_hooks(
-        datasette=datasette,
-        actor=actor,
-        action=action,
-    )
-
-    # If permission_sqls is the sentinel, skip all permission checks
-    # Return SQL that allows everything
-    from datasette.utils.permissions import SKIP_PERMISSION_CHECKS
-
-    if permission_sqls is SKIP_PERMISSION_CHECKS:
-        return (
-            "SELECT NULL AS parent, NULL AS child, 1 AS allow, 'skip_permission_checks' AS reason, 'skip' AS source_plugin",
-            {},
-            [],
-        )
-
-    if not permission_sqls:
-        return (
-            "SELECT NULL AS parent, NULL AS child, 0 AS allow, NULL AS reason, NULL AS source_plugin WHERE 0",
-            {},
-            [],
-        )
-
-    union_parts = []
-    all_params = {}
-    restriction_sqls = []
-
-    for permission_sql in permission_sqls:
-        all_params.update(permission_sql.params or {})
-
-        # Collect restriction SQL filters
-        if permission_sql.restriction_sql:
-            restriction_sqls.append(permission_sql.restriction_sql)
-
-        # Skip plugins that only provide restriction_sql (no permission rules)
-        if permission_sql.sql is None:
-            continue
-
-        union_parts.append(f"""
-            SELECT parent, child, allow, reason, '{permission_sql.source}' AS source_plugin FROM (
-                {permission_sql.sql}
-            )
-            """.strip())
-
-    rules_union = " UNION ALL ".join(union_parts)
-    return rules_union, all_params, restriction_sqls
-
-
-async def check_permission_for_resource(
-    *,
-    datasette: "Datasette",
-    actor: dict | None,
-    action: str,
-    parent: str | None,
-    child: str | None,
-) -> bool:
-    """
-    Check if an actor has permission for a specific action on a specific resource.
-
-    Args:
-        datasette: The Datasette instance
-        actor: The actor dict (or None)
-        action: The action name
-        parent: The parent resource identifier (e.g., database name, or None)
-        child: The child resource identifier (e.g., table name, or None)
-
-    Returns:
-        True if the actor is allowed, False otherwise
-
-    This builds the cascading permission query and checks if the specific
-    resource is in the allowed set.
-    """
-    rules_union, all_params, restriction_sqls = await build_permission_rules_sql(
-        datasette, actor, action
-    )
-
-    # If no rules (empty SQL), default deny
-    if not rules_union:
-        return False
-
-    # Add parameters for the resource we're checking
-    all_params["_check_parent"] = parent
-    all_params["_check_child"] = child
-
-    # If there are restriction filters, check if the resource passes them first
-    if restriction_sqls:
-        # Check if resource is in restriction allowlist
-        # Database-level restrictions (parent, NULL) should match all children (parent, *)
-        # Wrap each restriction_sql in a subquery to avoid operator precedence issues
-        restriction_check = "\nINTERSECT\n".join(
-            f"SELECT * FROM ({sql})" for sql in restriction_sqls
-        )
-        restriction_query = f"""
-WITH restriction_list AS (
-    {restriction_check}
-)
-SELECT EXISTS (
-    SELECT 1 FROM restriction_list
-    WHERE (parent = :_check_parent OR parent IS NULL)
-      AND (child = :_check_child OR child IS NULL)
-) AS in_allowlist
-"""
-        result = await datasette.get_internal_database().execute(
-            restriction_query, all_params
-        )
-        if result.rows and not result.rows[0][0]:
-            # Resource not in restriction allowlist - deny
-            return False
-
-    query = f"""
-WITH
-all_rules AS (
-  {rules_union}
-),
-matched_rules AS (
-  SELECT ar.*,
-    CASE
-      WHEN ar.child IS NOT NULL THEN 2  -- child-level (most specific)
-      WHEN ar.parent IS NOT NULL THEN 1  -- parent-level
-      ELSE 0                             -- root/global
-    END AS depth
-  FROM all_rules ar
-  WHERE (ar.parent IS NULL OR ar.parent = :_check_parent)
-    AND (ar.child IS NULL OR ar.child = :_check_child)
-),
-winner AS (
-  SELECT *
-  FROM matched_rules
-  ORDER BY
-    depth DESC,                          -- specificity first (higher depth wins)
-    CASE WHEN allow=0 THEN 0 ELSE 1 END, -- then deny over allow
-    source_plugin                        -- stable tie-break
-  LIMIT 1
-)
-SELECT COALESCE((SELECT allow FROM winner), 0) AS is_allowed
-"""
-
-    # Execute the query against the internal database
-    result = await datasette.get_internal_database().execute(query, all_params)
-    if result.rows:
-        return bool(result.rows[0][0])
-    return False

datasette/utils/asgi.py

@@ -1,28 +1,12 @@
+import hashlib
 import json
-from typing import Optional
 from datasette.utils import MultiParams, calculate_etag
-from datasette.utils.multipart import (
-    parse_form_data,
-    MultipartParseError,
-    FormData,
-    DEFAULT_MAX_FILE_SIZE,
-    DEFAULT_MAX_REQUEST_SIZE,
-    DEFAULT_MAX_FIELDS,
-    DEFAULT_MAX_FILES,
-    DEFAULT_MAX_PARTS,
-    DEFAULT_MAX_FIELD_SIZE,
-    DEFAULT_MAX_MEMORY_FILE_SIZE,
-    DEFAULT_MAX_PART_HEADER_BYTES,
-    DEFAULT_MAX_PART_HEADER_LINES,
-    DEFAULT_MIN_FREE_DISK_BYTES,
-)
 from mimetypes import guess_type
 from urllib.parse import parse_qs, urlunparse, parse_qsl
 from pathlib import Path
 from http.cookies import SimpleCookie, Morsel
 import aiofiles
 import aiofiles.os
-import re
 
 # Workaround for adding samesite support to pre 3.8 python
 Morsel._reserved["samesite"] = "SameSite"
@@ -155,71 +139,6 @@ class Request:
         body = await self.post_body()
         return dict(parse_qsl(body.decode("utf-8"), keep_blank_values=True))
 
-    async def form(
-        self,
-        files: bool = False,
-        max_file_size: int = DEFAULT_MAX_FILE_SIZE,
-        max_request_size: int = DEFAULT_MAX_REQUEST_SIZE,
-        max_fields: int = DEFAULT_MAX_FIELDS,
-        max_files: int = DEFAULT_MAX_FILES,
-        max_parts: Optional[int] = DEFAULT_MAX_PARTS,
-        max_field_size: int = DEFAULT_MAX_FIELD_SIZE,
-        max_memory_file_size: int = DEFAULT_MAX_MEMORY_FILE_SIZE,
-        max_part_header_bytes: int = DEFAULT_MAX_PART_HEADER_BYTES,
-        max_part_header_lines: int = DEFAULT_MAX_PART_HEADER_LINES,
-        min_free_disk_bytes: int = DEFAULT_MIN_FREE_DISK_BYTES,
-    ) -> FormData:
-        """
-        Parse form data from the request body.
-
-        Supports both application/x-www-form-urlencoded and multipart/form-data.
-
-        Args:
-            files: If True, store file uploads; if False (default), discard them
-            max_file_size: Maximum size per file in bytes (default 50MB)
-            max_request_size: Maximum total request size in bytes (default 100MB)
-            max_fields: Maximum number of form fields (default 1000)
-            max_files: Maximum number of file uploads (default 100)
-            max_parts: Maximum number of multipart parts (default max_fields + max_files)
-            max_field_size: Maximum size of a text field value in bytes (default 100KB)
-            max_memory_file_size: Threshold before files spill to disk (default 1MB)
-            max_part_header_bytes: Maximum bytes allowed in part headers (default 16KB)
-            max_part_header_lines: Maximum header lines per part (default 100)
-            min_free_disk_bytes: Minimum free bytes required in temp dir (default 50MB)
-
-        Returns:
-            FormData object with dict-like access to fields and files.
-            Use form["key"] for first value, form.getlist("key") for all values.
-
-        Raises:
-            BadRequest: If content-type is missing, unsupported, or parsing fails
-        """
-        content_type = self.headers.get("content-type", "")
-        if not content_type:
-            raise BadRequest(
-                "Missing Content-Type header; expected application/x-www-form-urlencoded "
-                "or multipart/form-data"
-            )
-
-        try:
-            return await parse_form_data(
-                receive=self.receive,
-                content_type=content_type,
-                files=files,
-                max_file_size=max_file_size,
-                max_request_size=max_request_size,
-                max_fields=max_fields,
-                max_files=max_files,
-                max_parts=max_parts,
-                max_field_size=max_field_size,
-                max_memory_file_size=max_memory_file_size,
-                max_part_header_bytes=max_part_header_bytes,
-                max_part_header_lines=max_part_header_lines,
-                min_free_disk_bytes=min_free_disk_bytes,
-            )
-        except MultipartParseError as e:
-            raise BadRequest(str(e))
-
     @classmethod
     def fake(cls, path_with_query_string, method="GET", scheme="http", url_vars=None):
         """Useful for constructing Request objects for tests"""
@@ -330,9 +249,6 @@ async def asgi_send_html(send, html, status=200, headers=None):
 
 
 async def asgi_send_redirect(send, location, status=302):
-    # Prevent open redirect vulnerability: strip multiple leading slashes
-    # //example.com would be interpreted as a protocol-relative URL (e.g., https://example.com/)
-    location = re.sub(r"^/+", "/", location)
     await asgi_send(
         send,
         "",

datasette/utils/check_callable.py

@@ -1,4 +1,4 @@
-import inspect
+import asyncio
 import types
 from typing import NamedTuple, Any
 
@@ -17,9 +17,9 @@ def check_callable(obj: Any) -> CallableStatus:
         return CallableStatus(True, False)
 
     if isinstance(obj, types.FunctionType):
-        return CallableStatus(True, inspect.iscoroutinefunction(obj))
+        return CallableStatus(True, asyncio.iscoroutinefunction(obj))
 
     if hasattr(obj, "__call__"):
-        return CallableStatus(True, inspect.iscoroutinefunction(obj.__call__))
+        return CallableStatus(True, asyncio.iscoroutinefunction(obj.__call__))
 
     assert False, "obj {} is somehow callable with no __call__ method".format(repr(obj))

datasette/utils/internal_db.py

@@ -3,7 +3,8 @@ from datasette.utils import table_column_details
 
 
 async def init_internal_db(db):
-    create_tables_sql = textwrap.dedent("""
+    create_tables_sql = textwrap.dedent(
+        """
     CREATE TABLE IF NOT EXISTS catalog_databases (
         database_name TEXT PRIMARY KEY,
         path TEXT,
@@ -67,13 +68,16 @@ async def init_internal_db(db):
         FOREIGN KEY (database_name) REFERENCES catalog_databases(database_name),
         FOREIGN KEY (database_name, table_name) REFERENCES catalog_tables(database_name, table_name)
     );
-    """).strip()
+    """
+    ).strip()
     await db.execute_write_script(create_tables_sql)
     await initialize_metadata_tables(db)
 
 
 async def initialize_metadata_tables(db):
-    await db.execute_write_script(textwrap.dedent("""
+    await db.execute_write_script(
+        textwrap.dedent(
+            """
         CREATE TABLE IF NOT EXISTS metadata_instance (
             key text,
             value text,
@@ -103,38 +107,9 @@ async def initialize_metadata_tables(db):
             value text,
             unique(database_name, resource_name, column_name, key)
         );
-
-        CREATE TABLE IF NOT EXISTS column_types (
-            database_name TEXT NOT NULL,
-            resource_name TEXT NOT NULL,
-            column_name TEXT NOT NULL,
-            column_type TEXT NOT NULL,
-            config TEXT,
-            PRIMARY KEY (database_name, resource_name, column_name)
-        );
-
-        CREATE TABLE IF NOT EXISTS queries (
-            database_name TEXT NOT NULL,
-            name TEXT NOT NULL,
-            sql TEXT NOT NULL,
-            title TEXT,
-            description TEXT,
-            description_html TEXT,
-            options TEXT NOT NULL DEFAULT '{}',
-            parameters TEXT NOT NULL DEFAULT '[]',
-            is_write INTEGER NOT NULL DEFAULT 0 CHECK (is_write IN (0, 1)),
-            is_private INTEGER NOT NULL DEFAULT 0 CHECK (is_private IN (0, 1)),
-            is_trusted INTEGER NOT NULL DEFAULT 0 CHECK (is_trusted IN (0, 1)),
-            source TEXT NOT NULL DEFAULT 'user',
-            owner_id TEXT,
-            created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-            updated_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP,
-            PRIMARY KEY (database_name, name)
-        );
-
-        CREATE INDEX IF NOT EXISTS queries_owner_idx
-            ON queries(owner_id);
-            """))
+            """
+        )
+    )
 
 
 async def populate_schema_tables(internal_db, db):

datasette/utils/multipart.py

@@ -1,757 +0,0 @@
-"""
-Streaming multipart/form-data parser for ASGI applications.
-
-Supports:
-- Streaming parsing without buffering entire body in memory
-- Files spill to disk above configurable threshold
-- Security limits on request size, file size, field count
-- Both multipart/form-data and application/x-www-form-urlencoded
-"""
-
-import asyncio
-import shutil
-import tempfile
-from dataclasses import dataclass, field
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    List,
-    Optional,
-    Tuple,
-    Union,
-)
-from urllib.parse import parse_qsl
-
-# Centralized defaults for multipart/form-data parsing
-DEFAULT_MAX_FILE_SIZE = 50 * 1024 * 1024  # 50MB
-DEFAULT_MAX_REQUEST_SIZE = 100 * 1024 * 1024  # 100MB
-DEFAULT_MAX_FIELDS = 1000
-DEFAULT_MAX_FILES = 100
-# If max_parts is not specified, it defaults to max_fields + max_files
-DEFAULT_MAX_PARTS: Optional[int] = None
-DEFAULT_MAX_FIELD_SIZE = 100 * 1024  # 100KB
-DEFAULT_MAX_MEMORY_FILE_SIZE = 1024 * 1024  # 1MB
-DEFAULT_MAX_PART_HEADER_BYTES = 16 * 1024  # 16KB
-DEFAULT_MAX_PART_HEADER_LINES = 100
-DEFAULT_MIN_FREE_DISK_BYTES = 50 * 1024 * 1024  # 50MB
-
-
-class MultipartParseError(Exception):
-    """Raised when multipart parsing fails."""
-
-    pass
-
-
-@dataclass
-class UploadedFile:
-    """
-    Represents an uploaded file from a multipart form.
-
-    Attributes:
-        name: The form field name
-        filename: The original filename from the upload
-        content_type: The MIME type of the file
-        size: Size in bytes
-    """
-
-    name: str
-    filename: str
-    content_type: Optional[str]
-    size: int
-    _file: tempfile.SpooledTemporaryFile = field(repr=False)
-
-    async def read(self, size: int = -1) -> bytes:
-        """Read file contents."""
-        return await asyncio.to_thread(self._file.read, size)
-
-    async def seek(self, offset: int, whence: int = 0) -> int:
-        """Seek to position in file."""
-        return await asyncio.to_thread(self._file.seek, offset, whence)
-
-    async def close(self) -> None:
-        """Close the underlying file."""
-        await asyncio.to_thread(self._file.close)
-
-    def close_sync(self) -> None:
-        """Close the underlying file synchronously."""
-        self._file.close()
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb):
-        await self.close()
-
-    def __del__(self):
-        try:
-            self._file.close()
-        except Exception:
-            pass
-
-
-class FormData:
-    """
-    Container for parsed form data, supporting both fields and files.
-
-    Provides dict-like access with support for multiple values per key.
-    """
-
-    def __init__(self):
-        self._data: List[Tuple[str, Union[str, UploadedFile]]] = []
-
-    def append(self, key: str, value: Union[str, UploadedFile]) -> None:
-        """Add a key-value pair."""
-        self._data.append((key, value))
-
-    def __getitem__(self, key: str) -> Union[str, UploadedFile]:
-        """Get the first value for a key."""
-        for k, v in self._data:
-            if k == key:
-                return v
-        raise KeyError(key)
-
-    def get(self, key: str, default: Any = None) -> Optional[Union[str, UploadedFile]]:
-        """Get the first value for a key, or default if not found."""
-        try:
-            return self[key]
-        except KeyError:
-            return default
-
-    def getlist(self, key: str) -> List[Union[str, UploadedFile]]:
-        """Get all values for a key."""
-        return [v for k, v in self._data if k == key]
-
-    def __contains__(self, key: str) -> bool:
-        """Check if key exists."""
-        return any(k == key for k, _ in self._data)
-
-    def __len__(self) -> int:
-        """Return number of items."""
-        return len(self._data)
-
-    def __iter__(self):
-        """Iterate over unique keys."""
-        seen = set()
-        for k, _ in self._data:
-            if k not in seen:
-                seen.add(k)
-                yield k
-
-    def keys(self):
-        """Return unique keys."""
-        return list(self)
-
-    def items(self) -> List[Tuple[str, Union[str, UploadedFile]]]:
-        """Return all key-value pairs."""
-        return list(self._data)
-
-    def values(self) -> List[Union[str, UploadedFile]]:
-        """Return all values."""
-        return [v for _, v in self._data]
-
-    def _uploaded_files(self) -> List[UploadedFile]:
-        """Return UploadedFile instances contained in this form."""
-        return [v for _, v in self._data if isinstance(v, UploadedFile)]
-
-    def close(self) -> None:
-        """
-        Close any uploaded files.
-
-        This provides deterministic cleanup for spooled temp files.
-        """
-        for uploaded in self._uploaded_files():
-            try:
-                uploaded.close_sync()
-            except Exception:
-                # Best-effort cleanup; ignore close errors
-                pass
-
-    async def aclose(self) -> None:
-        """Asynchronously close any uploaded files."""
-        for uploaded in self._uploaded_files():
-            try:
-                await uploaded.close()
-            except Exception:
-                # Best-effort cleanup; ignore close errors
-                pass
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc, tb):
-        self.close()
-
-    async def __aenter__(self):
-        return self
-
-    async def __aexit__(self, exc_type, exc, tb):
-        await self.aclose()
-
-
-def parse_content_disposition(header: str) -> Dict[str, Optional[str]]:
-    """
-    Parse Content-Disposition header value.
-
-    Returns dict with 'name', 'filename' keys (filename may be None).
-    """
-    result: Dict[str, Optional[str]] = {"name": None, "filename": None}
-
-    # Split on semicolons, handling quoted strings
-    parts = []
-    current = ""
-    in_quotes = False
-    i = 0
-    while i < len(header):
-        char = header[i]
-        if char == '"' and (i == 0 or header[i - 1] != "\\"):
-            in_quotes = not in_quotes
-            current += char
-        elif char == ";" and not in_quotes:
-            parts.append(current.strip())
-            current = ""
-        else:
-            current += char
-        i += 1
-    if current.strip():
-        parts.append(current.strip())
-
-    for part in parts[1:]:  # Skip the "form-data" part
-        if "=" not in part:
-            continue
-
-        key, _, value = part.partition("=")
-        key = key.strip().lower()
-        value = value.strip()
-
-        # Handle filename* (RFC 5987 encoding)
-        if key == "filename*":
-            # Format: utf-8''encoded_filename or charset'language'encoded_filename
-            if "'" in value:
-                parts_star = value.split("'", 2)
-                if len(parts_star) >= 3:
-                    # charset = parts_star[0]
-                    # language = parts_star[1]
-                    encoded = parts_star[2]
-                    # URL decode
-                    try:
-                        from urllib.parse import unquote
-
-                        result["filename"] = unquote(encoded, encoding="utf-8")
-                    except Exception:
-                        pass
-            continue
-
-        # Remove quotes if present
-        if value.startswith('"') and value.endswith('"'):
-            value = value[1:-1]
-            # Unescape backslash sequences
-            value = value.replace('\\"', '"').replace("\\\\", "\\")
-
-        if key == "name":
-            result["name"] = value
-        elif key == "filename":
-            # Only set if filename* hasn't already set it
-            if result["filename"] is None:
-                # Strip path components (security)
-                # Handle both Unix and Windows paths
-                value = value.replace("\\", "/")
-                if "/" in value:
-                    value = value.rsplit("/", 1)[-1]
-                result["filename"] = value
-
-    return result
-
-
-def parse_content_type(header: str) -> Tuple[str, Dict[str, str]]:
-    """
-    Parse Content-Type header value.
-
-    Returns (media_type, parameters_dict).
-    """
-    parts = header.split(";")
-    media_type = parts[0].strip().lower()
-    params = {}
-
-    for part in parts[1:]:
-        part = part.strip()
-        if "=" in part:
-            key, _, value = part.partition("=")
-            key = key.strip().lower()
-            value = value.strip()
-            # Remove quotes if present
-            if value.startswith('"') and value.endswith('"'):
-                value = value[1:-1]
-            params[key] = value
-
-    return media_type, params
-
-
-class MultipartParser:
-    """
-    Streaming multipart/form-data parser.
-
-    Processes the body chunk by chunk without loading everything into memory.
-    """
-
-    # Parser states
-    STATE_PREAMBLE = 0
-    STATE_HEADER = 1
-    STATE_BODY = 2
-    STATE_DONE = 3
-
-    def __init__(
-        self,
-        boundary: bytes,
-        max_file_size: int = DEFAULT_MAX_FILE_SIZE,
-        max_request_size: int = DEFAULT_MAX_REQUEST_SIZE,
-        max_fields: int = DEFAULT_MAX_FIELDS,
-        max_files: int = DEFAULT_MAX_FILES,
-        max_parts: Optional[int] = DEFAULT_MAX_PARTS,
-        max_field_size: int = DEFAULT_MAX_FIELD_SIZE,
-        max_memory_file_size: int = DEFAULT_MAX_MEMORY_FILE_SIZE,
-        max_part_header_bytes: int = DEFAULT_MAX_PART_HEADER_BYTES,
-        max_part_header_lines: int = DEFAULT_MAX_PART_HEADER_LINES,
-        min_free_disk_bytes: int = DEFAULT_MIN_FREE_DISK_BYTES,
-        handle_files: bool = False,
-    ):
-        self.boundary = b"--" + boundary
-        self.end_boundary = self.boundary + b"--"
-        self.max_file_size = max_file_size
-        self.max_request_size = max_request_size
-        self.max_fields = max_fields
-        self.max_files = max_files
-        # If not specified, tie max_parts to the other cardinality limits
-        if max_parts is None:
-            max_parts = max_fields + max_files
-        self.max_parts = max_parts
-        self.max_field_size = max_field_size
-        self.max_memory_file_size = max_memory_file_size
-        self.max_part_header_bytes = max_part_header_bytes
-        self.max_part_header_lines = max_part_header_lines
-        self.min_free_disk_bytes = min_free_disk_bytes
-        self.handle_files = handle_files
-
-        self.state = self.STATE_PREAMBLE
-        self.buffer = bytearray()
-        self.total_bytes = 0
-        self.field_count = 0
-        self.file_count = 0
-        self.part_count = 0
-        self.current_part_size = 0
-        self.current_header_bytes = 0
-        self.current_header_lines = 0
-
-        self.form_data = FormData()
-        self._disk_check_interval_bytes = 1024 * 1024  # 1MB between disk checks
-        self._bytes_since_disk_check = 0
-        self._tempdir = tempfile.gettempdir()
-
-        # Current part state
-        self.current_headers: Dict[str, str] = {}
-        self.current_file: Optional[tempfile.SpooledTemporaryFile] = None
-        self.current_body = bytearray()
-        self.current_name: Optional[str] = None
-        self.current_filename: Optional[str] = None
-        self.current_content_type: Optional[str] = None
-
-    def feed(self, chunk: bytes) -> None:
-        """Feed a chunk of data to the parser."""
-        self.total_bytes += len(chunk)
-        if self.total_bytes > self.max_request_size:
-            raise MultipartParseError("Request body too large")
-
-        self.buffer.extend(chunk)
-        self._process()
-
-    def _process(self) -> None:
-        """Process buffered data."""
-        while True:
-            if self.state == self.STATE_PREAMBLE:
-                if not self._process_preamble():
-                    break
-            elif self.state == self.STATE_HEADER:
-                if not self._process_header():
-                    break
-            elif self.state == self.STATE_BODY:
-                if not self._process_body():
-                    break
-            elif self.state == self.STATE_DONE:
-                break
-
-    def _process_preamble(self) -> bool:
-        """Skip preamble and find first boundary."""
-        # Look for boundary (could be at start or after preamble)
-        # Try both \r\n prefixed and bare boundary at start
-        idx = self.buffer.find(self.boundary)
-        if idx == -1:
-            # Keep potential partial boundary at end
-            keep = len(self.boundary) - 1
-            if len(self.buffer) > keep:
-                self.buffer = self.buffer[-keep:]
-            return False
-
-        # Found boundary, skip to after it
-        after_boundary = idx + len(self.boundary)
-
-        # Check for end boundary
-        if self.buffer[idx : idx + len(self.end_boundary)] == self.end_boundary:
-            self.state = self.STATE_DONE
-            return False
-
-        # Skip CRLF or LF after boundary
-        if after_boundary < len(self.buffer):
-            if self.buffer[after_boundary : after_boundary + 2] == b"\r\n":
-                after_boundary += 2
-            elif self.buffer[after_boundary : after_boundary + 1] == b"\n":
-                after_boundary += 1
-
-        self.buffer = self.buffer[after_boundary:]
-        self.state = self.STATE_HEADER
-        self.current_headers = {}
-        self.current_header_bytes = 0
-        self.current_header_lines = 0
-        return True
-
-    def _process_header(self) -> bool:
-        """Parse part headers."""
-        while True:
-            # Look for end of header line
-            crlf_idx = self.buffer.find(b"\r\n")
-            lf_idx = self.buffer.find(b"\n")
-
-            if crlf_idx == -1 and lf_idx == -1:
-                # Guard against unbounded header buffering if no newline is ever sent
-                if len(self.buffer) > self.max_part_header_bytes:
-                    raise MultipartParseError("Part headers too large")
-                return False  # Need more data
-
-            # Use whichever comes first
-            if crlf_idx != -1 and (lf_idx == -1 or crlf_idx < lf_idx):
-                idx = crlf_idx
-                line_end_len = 2
-            else:
-                idx = lf_idx
-                line_end_len = 1
-
-            line = self.buffer[:idx]
-            self.buffer = self.buffer[idx + line_end_len :]
-
-            self.current_header_lines += 1
-            self.current_header_bytes += idx + line_end_len
-            if (
-                self.current_header_lines > self.max_part_header_lines
-                or self.current_header_bytes > self.max_part_header_bytes
-            ):
-                raise MultipartParseError("Part headers too large")
-
-            if not line:
-                # Empty line = end of headers
-                self._start_body()
-                self.state = self.STATE_BODY
-                return True
-
-            # Parse header
-            try:
-                line_str = line.decode("utf-8", errors="replace")
-            except Exception:
-                line_str = line.decode("latin-1")
-
-            if ":" in line_str:
-                name, _, value = line_str.partition(":")
-                self.current_headers[name.strip().lower()] = value.strip()
-
-    def _start_body(self) -> None:
-        """Initialize body parsing for current part."""
-        self.part_count += 1
-        if self.part_count > self.max_parts:
-            raise MultipartParseError("Too many parts")
-
-        # Parse Content-Disposition
-        cd = self.current_headers.get("content-disposition", "")
-        parsed = parse_content_disposition(cd)
-        self.current_name = parsed.get("name")
-        self.current_filename = parsed.get("filename")
-        self.current_content_type = self.current_headers.get("content-type")
-        self.current_part_size = 0
-
-        if self.current_filename is not None:
-            # It's a file
-            self.file_count += 1
-            if self.file_count > self.max_files:
-                raise MultipartParseError("Too many files")
-            if self.handle_files:
-                self.current_file = tempfile.SpooledTemporaryFile(
-                    max_size=self.max_memory_file_size
-                )
-            else:
-                # Will discard file content
-                self.current_file = None
-        else:
-            # It's a text field
-            self.field_count += 1
-            if self.field_count > self.max_fields:
-                raise MultipartParseError("Too many fields")
-            self.current_body = bytearray()
-            self.current_file = None
-
-        # Check disk space before allocating a spooled temp file
-        if self.current_filename is not None and self.handle_files:
-            self._ensure_disk_space()
-
-    def _process_body(self) -> bool:
-        """Process body data for current part."""
-        # Look for boundary in buffer
-        # Need to handle boundary potentially split across chunks
-
-        # The boundary is preceded by \r\n (or \n for lenient parsing)
-        search_boundary = b"\r\n" + self.boundary
-
-        idx = self.buffer.find(search_boundary)
-        if idx == -1:
-            # Try LF-only boundary (lenient)
-            search_boundary_lf = b"\n" + self.boundary
-            idx = self.buffer.find(search_boundary_lf)
-            if idx != -1:
-                search_boundary = search_boundary_lf
-
-        if idx == -1:
-            # No boundary found yet
-            # Keep potential partial boundary at end of buffer
-            safe_len = len(self.buffer) - len(search_boundary) - 1
-            if safe_len > 0:
-                safe_data = self.buffer[:safe_len]
-                self._write_body_data(bytes(safe_data))
-                self.buffer = self.buffer[safe_len:]
-            return False
-
-        # Found boundary - write remaining body data
-        body_data = self.buffer[:idx]
-        self._write_body_data(bytes(body_data))
-
-        # Move past the boundary
-        after_boundary = idx + len(search_boundary)
-
-        # Check for end boundary
-        remaining = self.buffer[after_boundary:]
-        if remaining.startswith(b"--"):
-            # End boundary
-            self._finish_part()
-            self.state = self.STATE_DONE
-            return False
-
-        # Skip CRLF or LF after boundary
-        if remaining.startswith(b"\r\n"):
-            after_boundary += 2
-        elif remaining.startswith(b"\n"):
-            after_boundary += 1
-
-        self.buffer = self.buffer[after_boundary:]
-        self._finish_part()
-        self.state = self.STATE_HEADER
-        self.current_headers = {}
-        self.current_header_bytes = 0
-        self.current_header_lines = 0
-        return True
-
-    def _write_body_data(self, data: bytes) -> None:
-        """Write data to current part body."""
-        if not data:
-            return
-
-        self.current_part_size += len(data)
-
-        if self.current_filename is not None:
-            # File data
-            if self.current_part_size > self.max_file_size:
-                raise MultipartParseError("File too large")
-            if self.handle_files and self.current_file:
-                self._bytes_since_disk_check += len(data)
-                if self._bytes_since_disk_check >= self._disk_check_interval_bytes:
-                    self._ensure_disk_space()
-                    self._bytes_since_disk_check = 0
-                self.current_file.write(data)
-            # else: discard file data
-        else:
-            # Field data
-            if self.current_part_size > self.max_field_size:
-                raise MultipartParseError("Field value too large")
-            self.current_body.extend(data)
-
-    def _finish_part(self) -> None:
-        """Finalize current part and add to form data."""
-        if self.current_name is None:
-            return
-
-        if self.current_filename is not None:
-            # File
-            if self.handle_files and self.current_file:
-                self.current_file.seek(0)
-                uploaded = UploadedFile(
-                    name=self.current_name,
-                    filename=self.current_filename,
-                    content_type=self.current_content_type,
-                    size=self.current_part_size,
-                    _file=self.current_file,
-                )
-                self.form_data.append(self.current_name, uploaded)
-            # else: file was discarded
-        else:
-            # Text field
-            try:
-                value = bytes(self.current_body).decode("utf-8")
-            except UnicodeDecodeError:
-                value = bytes(self.current_body).decode("latin-1")
-            self.form_data.append(self.current_name, value)
-
-        # Reset part state
-        self.current_file = None
-        self.current_body = bytearray()
-        self.current_name = None
-        self.current_filename = None
-        self.current_content_type = None
-
-    def finalize(self) -> FormData:
-        """Finalize parsing and return form data."""
-        # Process any remaining data
-        self._process()
-        if self.state != self.STATE_DONE:
-            raise MultipartParseError(
-                "Truncated multipart body (missing closing boundary)"
-            )
-        return self.form_data
-
-    def _ensure_disk_space(self) -> None:
-        """
-        Ensure there is enough free space on the temp filesystem.
-
-        This is a best-effort guard against filling the disk with uploads.
-        """
-        if not self.handle_files:
-            return
-        if self.min_free_disk_bytes <= 0:
-            return
-        free_bytes = shutil.disk_usage(self._tempdir).free
-        if free_bytes < self.min_free_disk_bytes:
-            raise MultipartParseError("Insufficient disk space for uploads")
-
-
-async def parse_form_data(
-    receive: Callable,
-    content_type: str,
-    files: bool = False,
-    max_file_size: int = DEFAULT_MAX_FILE_SIZE,
-    max_request_size: int = DEFAULT_MAX_REQUEST_SIZE,
-    max_fields: int = DEFAULT_MAX_FIELDS,
-    max_files: int = DEFAULT_MAX_FILES,
-    max_parts: Optional[int] = DEFAULT_MAX_PARTS,
-    max_field_size: int = DEFAULT_MAX_FIELD_SIZE,
-    max_memory_file_size: int = DEFAULT_MAX_MEMORY_FILE_SIZE,
-    max_part_header_bytes: int = DEFAULT_MAX_PART_HEADER_BYTES,
-    max_part_header_lines: int = DEFAULT_MAX_PART_HEADER_LINES,
-    min_free_disk_bytes: int = DEFAULT_MIN_FREE_DISK_BYTES,
-) -> FormData:
-    """
-    Parse form data from an ASGI receive callable.
-
-    Supports both application/x-www-form-urlencoded and multipart/form-data.
-
-    Args:
-        receive: ASGI receive callable
-        content_type: Content-Type header value
-        files: If True, store file uploads; if False, discard them
-        max_file_size: Maximum size per file in bytes
-        max_request_size: Maximum total request size in bytes
-        max_fields: Maximum number of form fields
-        max_files: Maximum number of file uploads
-        max_field_size: Maximum size of a text field value
-        max_memory_file_size: File size threshold before spilling to disk
-
-    Returns:
-        FormData object containing parsed fields and files
-    """
-    media_type, params = parse_content_type(content_type)
-
-    if media_type == "application/x-www-form-urlencoded":
-        # Read entire body for URL-encoded forms (they're typically small)
-        body = bytearray()
-        total = 0
-        while True:
-            message = await receive()
-            message_type = message.get("type")
-            if message_type == "http.disconnect":
-                raise MultipartParseError("Client disconnected during request body")
-            if message_type is not None and message_type != "http.request":
-                continue
-            chunk = message.get("body", b"")
-            total += len(chunk)
-            if total > max_request_size:
-                raise MultipartParseError("Request body too large")
-            body.extend(chunk)
-            if not message.get("more_body", False):
-                break
-
-        form_data = FormData()
-        try:
-            pairs = parse_qsl(bytes(body).decode("utf-8"), keep_blank_values=True)
-        except UnicodeDecodeError:
-            pairs = parse_qsl(bytes(body).decode("latin-1"), keep_blank_values=True)
-
-        for key, value in pairs:
-            form_data.append(key, value)
-
-        return form_data
-
-    elif media_type == "multipart/form-data":
-        boundary = params.get("boundary")
-        if not boundary:
-            raise MultipartParseError("Missing boundary in Content-Type")
-
-        parser = MultipartParser(
-            boundary=boundary.encode("utf-8"),
-            max_file_size=max_file_size,
-            max_request_size=max_request_size,
-            max_fields=max_fields,
-            max_files=max_files,
-            max_parts=max_parts,
-            max_field_size=max_field_size,
-            max_memory_file_size=max_memory_file_size,
-            max_part_header_bytes=max_part_header_bytes,
-            max_part_header_lines=max_part_header_lines,
-            min_free_disk_bytes=min_free_disk_bytes,
-            handle_files=files,
-        )
-
-        # Stream body through parser
-        batch_target = 64 * 1024
-        batch = bytearray()
-
-        async def flush_batch() -> None:
-            if batch:
-                data = bytes(batch)
-                batch.clear()
-                await asyncio.to_thread(parser.feed, data)
-
-        while True:
-            message = await receive()
-            message_type = message.get("type")
-            if message_type == "http.disconnect":
-                raise MultipartParseError("Client disconnected during request body")
-            if message_type is not None and message_type != "http.request":
-                continue
-            chunk = message.get("body", b"")
-            if chunk:
-                batch.extend(chunk)
-                if len(batch) >= batch_target:
-                    await flush_batch()
-            if not message.get("more_body", False):
-                break
-
-        await flush_batch()
-        return await asyncio.to_thread(parser.finalize)
-
-    else:
-        raise MultipartParseError(
-            f"Unsupported Content-Type: {media_type}. "
-            "Expected application/x-www-form-urlencoded or multipart/form-data"
-        )

datasette/utils/permissions.py

@@ -1,125 +1,79 @@
 # perm_utils.py
 from __future__ import annotations
 
-import json
-from typing import Any, Dict, Iterable, List, Sequence, Tuple
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence, Tuple, Union
 import sqlite3
 
-from datasette.permissions import PermissionSQL
-from datasette.plugins import pm
-from datasette.utils import await_me_maybe
-
-# Sentinel object to indicate permission checks should be skipped
-SKIP_PERMISSION_CHECKS = object()
-
-
-async def gather_permission_sql_from_hooks(
-    *, datasette, actor: dict | None, action: str
-) -> List[PermissionSQL] | object:
-    """Collect PermissionSQL objects from the permission_resources_sql hook.
-
-    Ensures that each returned PermissionSQL has a populated ``source``.
-
-    Returns SKIP_PERMISSION_CHECKS sentinel if skip_permission_checks context variable
-    is set, signaling that all permission checks should be bypassed.
-    """
-    from datasette.permissions import _skip_permission_checks
-
-    # Check if we should skip permission checks BEFORE calling hooks
-    # This avoids creating unawaited coroutines
-    if _skip_permission_checks.get():
-        return SKIP_PERMISSION_CHECKS
-
-    hook_caller = pm.hook.permission_resources_sql
-    hookimpls = hook_caller.get_hookimpls()
-    hook_results = list(hook_caller(datasette=datasette, actor=actor, action=action))
-
-    collected: List[PermissionSQL] = []
-    actor_json = json.dumps(actor) if actor is not None else None
-    actor_id = actor.get("id") if isinstance(actor, dict) else None
-
-    for index, result in enumerate(hook_results):
-        hookimpl = hookimpls[index]
-        resolved = await await_me_maybe(result)
-        default_source = _plugin_name_from_hookimpl(hookimpl)
-        for permission_sql in _iter_permission_sql_from_result(resolved, action=action):
-            if not permission_sql.source:
-                permission_sql.source = default_source
-            params = permission_sql.params or {}
-            params.setdefault("action", action)
-            params.setdefault("actor", actor_json)
-            params.setdefault("actor_id", actor_id)
-            collected.append(permission_sql)
-
-    return collected
-
-
-def _plugin_name_from_hookimpl(hookimpl) -> str:
-    if getattr(hookimpl, "plugin_name", None):
-        return hookimpl.plugin_name
-    plugin = getattr(hookimpl, "plugin", None)
-    if hasattr(plugin, "__name__"):
-        return plugin.__name__
-    return repr(plugin)
-
-
-def _iter_permission_sql_from_result(
-    result: Any, *, action: str
-) -> Iterable[PermissionSQL]:
-    if result is None:
-        return []
-    if isinstance(result, PermissionSQL):
-        return [result]
-    if isinstance(result, (list, tuple)):
-        collected: List[PermissionSQL] = []
-        for item in result:
-            collected.extend(_iter_permission_sql_from_result(item, action=action))
-        return collected
-    if callable(result):
-        permission_sql = result(action)  # type: ignore[call-arg]
-        return _iter_permission_sql_from_result(permission_sql, action=action)
-    raise TypeError(
-        "Plugin providers must return PermissionSQL instances, sequences, or callables"
-    )
-
 
 # -----------------------------
 # Plugin interface & utilities
 # -----------------------------
 
 
+@dataclass
+class PluginSQL:
+    """
+    A plugin contributes SQL that yields:
+      parent TEXT NULL,
+      child  TEXT NULL,
+      allow  INTEGER,    -- 1 allow, 0 deny
+      reason TEXT
+    """
+
+    source: str  # identifier used for auditing (e.g., plugin name)
+    sql: str  # SQL that SELECTs the 4 columns above
+    params: Dict[str, Any]  # bound params for the SQL (values only; no ':' prefix)
+
+
+def _namespace_params(i: int, params: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
+    """
+    Rewrite parameter placeholders to distinct names per plugin block.
+    Returns (rewritten_sql, namespaced_params).
+    """
+
+    replacements = {key: f"{key}_{i}" for key in params.keys()}
+
+    def rewrite(s: str) -> str:
+        for key in sorted(replacements.keys(), key=len, reverse=True):
+            s = s.replace(f":{key}", f":{replacements[key]}")
+        return s
+
+    namespaced: Dict[str, Any] = {}
+    for key, value in params.items():
+        namespaced[replacements[key]] = value
+    return rewrite, namespaced
+
+
+PluginProvider = Callable[[str], PluginSQL]
+PluginOrFactory = Union[PluginSQL, PluginProvider]
+
+
 def build_rules_union(
-    actor: dict | None, plugins: Sequence[PermissionSQL]
+    actor: str, plugins: Sequence[PluginSQL]
 ) -> Tuple[str, Dict[str, Any]]:
     """
-    Compose plugin SQL into a UNION ALL.
+    Compose plugin SQL into a UNION ALL with namespaced parameters.
 
     Returns:
       union_sql: a SELECT with columns (parent, child, allow, reason, source_plugin)
-      params:    dict of bound parameters including :actor (JSON), :actor_id, and plugin params
-
-    Note: Plugins are responsible for ensuring their parameter names don't conflict.
-    The system reserves these parameter names: :actor, :actor_id, :action, :filter_parent
-    Plugin parameters should be prefixed with a unique identifier (e.g., source name).
+      params:    dict of bound parameters including :actor and namespaced plugin params
     """
     parts: List[str] = []
-    actor_json = json.dumps(actor) if actor else None
-    actor_id = actor.get("id") if actor else None
-    params: Dict[str, Any] = {"actor": actor_json, "actor_id": actor_id}
+    params: Dict[str, Any] = {"actor": actor}
 
-    for p in plugins:
-        # No namespacing - just use plugin params as-is
-        params.update(p.params or {})
+    for i, p in enumerate(plugins):
+        rewrite, ns_params = _namespace_params(i, p.params)
+        sql_block = rewrite(p.sql)
+        params.update(ns_params)
 
-        # Skip plugins that only provide restriction_sql (no permission rules)
-        if p.sql is None:
-            continue
-
-        parts.append(f"""
+        parts.append(
+            f"""
             SELECT parent, child, allow, reason, '{p.source}' AS source_plugin FROM (
-                {p.sql}
+                {sql_block}
             )
-            """.strip())
+            """.strip()
+        )
 
     if not parts:
         # Empty UNION that returns no rows
@@ -137,11 +91,11 @@ def build_rules_union(
 
 async def resolve_permissions_from_catalog(
     db,
-    actor: dict | None,
-    plugins: Sequence[Any],
+    actor: str,
+    plugins: Sequence[PluginOrFactory],
     action: str,
     candidate_sql: str,
-    candidate_params: Dict[str, Any] | None = None,
+    candidate_params: Optional[Dict[str, Any]] = None,
     *,
     implicit_deny: bool = True,
 ) -> List[Dict[str, Any]]:
@@ -153,9 +107,8 @@ async def resolve_permissions_from_catalog(
         (Use child=NULL for parent-scoped actions like "execute-sql".)
       - *db* exposes: rows = await db.execute(sql, params)
         where rows is an iterable of sqlite3.Row
-      - plugins: hook results handled by await_me_maybe - can be sync/async,
-        single PermissionSQL, list, or callable returning PermissionSQL
-      - actor is the actor dict (or None), made available as :actor (JSON), :actor_id, and :action
+      - plugins are either PluginSQL objects or callables accepting (action: str)
+        and returning PluginSQL instances selecting (parent, child, allow, reason)
 
     Decision policy:
       1) Specificity first: child (depth=2) > parent (depth=1) > root (depth=0)
@@ -168,26 +121,21 @@ async def resolve_permissions_from_catalog(
       - parent, child, allow, reason, source_plugin, depth
       - resource (rendered "/parent/child" or "/parent" or "/")
     """
-    resolved_plugins: List[PermissionSQL] = []
-    restriction_sqls: List[str] = []
-
+    resolved_plugins: List[PluginSQL] = []
     for plugin in plugins:
-        if callable(plugin) and not isinstance(plugin, PermissionSQL):
+        if callable(plugin) and not isinstance(plugin, PluginSQL):
             resolved = plugin(action)  # type: ignore[arg-type]
         else:
             resolved = plugin  # type: ignore[assignment]
-        if not isinstance(resolved, PermissionSQL):
-            raise TypeError("Plugin providers must return PermissionSQL instances")
+        if not isinstance(resolved, PluginSQL):
+            raise TypeError("Plugin providers must return PluginSQL instances")
         resolved_plugins.append(resolved)
 
-        # Collect restriction SQL filters
-        if resolved.restriction_sql:
-            restriction_sqls.append(resolved.restriction_sql)
-
     union_sql, rule_params = build_rules_union(actor, resolved_plugins)
     all_params = {
         **(candidate_params or {}),
         **rule_params,
+        "actor": actor,
         "action": action,
     }
 
@@ -219,8 +167,8 @@ async def resolve_permissions_from_catalog(
                  PARTITION BY parent, child
                  ORDER BY
                    depth DESC,                          -- specificity first
-                   CASE WHEN allow=0 THEN 0 ELSE 1 END, -- then deny over allow at same depth
-                   source_plugin                        -- stable tie-break
+                   CASE WHEN allow=0 THEN 0 ELSE 1 END, -- deny over allow at same depth
+                   source_plugin                         -- stable tie-break
                ) AS rn
         FROM matched
     ),
@@ -248,145 +196,6 @@ async def resolve_permissions_from_catalog(
     ORDER BY c.parent, c.child
     """
 
-    # If there are restriction filters, wrap the query with INTERSECT
-    # This ensures only resources in the restriction allowlist are returned
-    if restriction_sqls:
-        # Start with the main query, but select only parent/child for the INTERSECT
-        main_query_for_intersect = f"""
-        WITH
-        cands AS (
-            {candidate_sql}
-        ),
-        rules AS (
-            {union_sql}
-        ),
-        matched AS (
-            SELECT
-                c.parent, c.child,
-                r.allow, r.reason, r.source_plugin,
-                CASE
-                  WHEN r.child  IS NOT NULL THEN 2  -- child-level (most specific)
-                  WHEN r.parent IS NOT NULL THEN 1  -- parent-level
-                  ELSE 0                            -- root/global
-                END AS depth
-            FROM cands c
-            JOIN rules r
-              ON (r.parent IS NULL OR r.parent = c.parent)
-             AND (r.child  IS NULL OR r.child  = c.child)
-        ),
-        ranked AS (
-            SELECT *,
-                   ROW_NUMBER() OVER (
-                     PARTITION BY parent, child
-                     ORDER BY
-                       depth DESC,                          -- specificity first
-                       CASE WHEN allow=0 THEN 0 ELSE 1 END, -- then deny over allow at same depth
-                       source_plugin                        -- stable tie-break
-                   ) AS rn
-            FROM matched
-        ),
-        winner AS (
-            SELECT parent, child,
-                   allow, reason, source_plugin, depth
-            FROM ranked WHERE rn = 1
-        ),
-        permitted_resources AS (
-            SELECT c.parent, c.child
-            FROM cands c
-            LEFT JOIN winner w
-              ON ((w.parent = c.parent) OR (w.parent IS NULL AND c.parent IS NULL))
-             AND ((w.child  = c.child ) OR (w.child  IS NULL AND c.child  IS NULL))
-            WHERE COALESCE(w.allow, CASE WHEN :implicit_deny THEN 0 ELSE NULL END) = 1
-        )
-        SELECT parent, child FROM permitted_resources
-        """
-
-        # Build restriction list with INTERSECT (all must match)
-        # Then filter to resources that match hierarchically
-        # Wrap each restriction_sql in a subquery to avoid operator precedence issues
-        # with UNION ALL inside the restriction SQL statements
-        restriction_intersect = "\nINTERSECT\n".join(
-            f"SELECT * FROM ({sql})" for sql in restriction_sqls
-        )
-
-        # Combine: resources allowed by permissions AND in restriction allowlist
-        # Database-level restrictions (parent, NULL) should match all children (parent, *)
-        filtered_resources = f"""
-        WITH restriction_list AS (
-            {restriction_intersect}
-        ),
-        permitted AS (
-            {main_query_for_intersect}
-        ),
-        filtered AS (
-            SELECT p.parent, p.child
-            FROM permitted p
-            WHERE EXISTS (
-                SELECT 1 FROM restriction_list r
-                WHERE (r.parent = p.parent OR r.parent IS NULL)
-                  AND (r.child = p.child OR r.child IS NULL)
-            )
-        )
-        """
-
-        # Now join back to get full results for only the filtered resources
-        sql = f"""
-        {filtered_resources}
-        , cands AS (
-            {candidate_sql}
-        ),
-        rules AS (
-            {union_sql}
-        ),
-        matched AS (
-            SELECT
-                c.parent, c.child,
-                r.allow, r.reason, r.source_plugin,
-                CASE
-                  WHEN r.child  IS NOT NULL THEN 2  -- child-level (most specific)
-                  WHEN r.parent IS NOT NULL THEN 1  -- parent-level
-                  ELSE 0                            -- root/global
-                END AS depth
-            FROM cands c
-            JOIN rules r
-              ON (r.parent IS NULL OR r.parent = c.parent)
-             AND (r.child  IS NULL OR r.child  = c.child)
-        ),
-        ranked AS (
-            SELECT *,
-                   ROW_NUMBER() OVER (
-                     PARTITION BY parent, child
-                     ORDER BY
-                       depth DESC,                          -- specificity first
-                       CASE WHEN allow=0 THEN 0 ELSE 1 END, -- then deny over allow at same depth
-                       source_plugin                        -- stable tie-break
-                   ) AS rn
-            FROM matched
-        ),
-        winner AS (
-            SELECT parent, child,
-                   allow, reason, source_plugin, depth
-            FROM ranked WHERE rn = 1
-        )
-        SELECT
-          c.parent, c.child,
-          COALESCE(w.allow, CASE WHEN :implicit_deny THEN 0 ELSE NULL END) AS allow,
-          COALESCE(w.reason, CASE WHEN :implicit_deny THEN 'implicit deny' ELSE NULL END) AS reason,
-          w.source_plugin,
-          COALESCE(w.depth, -1) AS depth,
-          :action AS action,
-          CASE
-            WHEN c.parent IS NULL THEN '/'
-            WHEN c.child  IS NULL THEN '/' || c.parent
-            ELSE '/' || c.parent || '/' || c.child
-          END AS resource
-        FROM filtered c
-        LEFT JOIN winner w
-          ON ((w.parent = c.parent) OR (w.parent IS NULL AND c.parent IS NULL))
-         AND ((w.child  = c.child ) OR (w.child  IS NULL AND c.child  IS NULL))
-        ORDER BY c.parent, c.child
-        """
-
     rows_iter: Iterable[sqlite3.Row] = await db.execute(
         sql,
         {**all_params, "implicit_deny": 1 if implicit_deny else 0},
@@ -396,9 +205,9 @@ async def resolve_permissions_from_catalog(
 
 async def resolve_permissions_with_candidates(
     db,
-    actor: dict | None,
-    plugins: Sequence[Any],
-    candidates: List[Tuple[str, str | None]],
+    actor: str,
+    plugins: Sequence[PluginOrFactory],
+    candidates: List[Tuple[str, Optional[str]]],
     action: str,
     *,
     implicit_deny: bool = True,
@@ -408,7 +217,6 @@ async def resolve_permissions_with_candidates(
     the candidates as a UNION of parameterized SELECTs in a CTE.
 
     candidates: list of (parent, child) where child can be None for parent-scoped actions.
-    actor: actor dict (or None), made available as :actor (JSON), :actor_id, and :action
     """
     # Build a small CTE for candidates.
     cand_rows_sql: List[str] = []

datasette/utils/sql_analysis.py

@@ -1,550 +0,0 @@
-from dataclasses import dataclass
-from typing import Literal
-
-from datasette.utils.sqlite import SQLiteTableType, sqlite3, sqlite_table_type
-
-SQLOperation = Literal[
-    "read",
-    "insert",
-    "update",
-    "delete",
-    "select",
-    "function",
-    "create",
-    "alter",
-    "drop",
-    "begin",
-    "commit",
-    "rollback",
-    "savepoint",
-    "attach",
-    "detach",
-    "pragma",
-    "analyze",
-    "reindex",
-    "vacuum",
-    "unknown",
-]
-SQLTargetType = Literal[
-    "table",
-    "index",
-    "view",
-    "trigger",
-    "virtual-table",
-    "schema",
-    "statement",
-    "transaction",
-    "database",
-    "pragma",
-    "function",
-    "unknown",
-]
-SQLTableOperation = Literal["read", "insert", "update", "delete"]
-SQLSchemaOperation = Literal["create", "drop"]
-SQLSchemaTargetType = Literal["index", "table", "trigger", "view", "virtual-table"]
-
-
-@dataclass(frozen=True)
-class Operation:
-    operation: SQLOperation
-    target_type: SQLTargetType
-    database: str | None
-    table: str | None
-    sqlite_schema: str | None
-    table_kind: SQLiteTableType | None = None
-    target: str | None = None
-    columns: tuple[str, ...] = ()
-    source: str | None = None
-    internal: bool = False
-
-
-@dataclass(frozen=True)
-class SQLAnalysis:
-    operations: tuple[Operation, ...]
-
-
-# Hashable dict key for grouping repeated authorizer callbacks while collecting columns.
-@dataclass(frozen=True)
-class OperationKey:
-    operation: SQLOperation
-    target_type: SQLTargetType
-    database: str | None
-    table: str | None
-    sqlite_schema: str | None
-    target: str | None
-    source: str | None
-    internal: bool
-
-
-_ACTION_TO_OPERATION: dict[int, SQLTableOperation] = {
-    sqlite3.SQLITE_READ: "read",
-    sqlite3.SQLITE_INSERT: "insert",
-    sqlite3.SQLITE_UPDATE: "update",
-    sqlite3.SQLITE_DELETE: "delete",
-}
-
-# Values are (operation, target_type) pairs used to construct Operation objects.
-_CREATE_ACTIONS: dict[int, tuple[SQLSchemaOperation, SQLSchemaTargetType]] = {
-    sqlite3.SQLITE_CREATE_INDEX: ("create", "index"),
-    sqlite3.SQLITE_CREATE_TABLE: ("create", "table"),
-    sqlite3.SQLITE_CREATE_TRIGGER: ("create", "trigger"),
-    sqlite3.SQLITE_CREATE_VIEW: ("create", "view"),
-}
-_DROP_ACTIONS: dict[int, tuple[SQLSchemaOperation, SQLSchemaTargetType]] = {
-    sqlite3.SQLITE_DROP_INDEX: ("drop", "index"),
-    sqlite3.SQLITE_DROP_TABLE: ("drop", "table"),
-    sqlite3.SQLITE_DROP_TRIGGER: ("drop", "trigger"),
-    sqlite3.SQLITE_DROP_VIEW: ("drop", "view"),
-}
-
-
-def _add_schema_action(
-    action_name: str,
-    operation: SQLSchemaOperation,
-    target_type: SQLSchemaTargetType,
-) -> None:
-    action_value = getattr(sqlite3, action_name, None)
-    if action_value is not None:
-        actions = _CREATE_ACTIONS if operation == "create" else _DROP_ACTIONS
-        actions[action_value] = (operation, target_type)
-
-
-_TEMP_SCHEMA_ACTIONS: tuple[
-    tuple[str, SQLSchemaOperation, SQLSchemaTargetType], ...
-] = (
-    ("SQLITE_CREATE_TEMP_INDEX", "create", "index"),
-    ("SQLITE_CREATE_TEMP_TABLE", "create", "table"),
-    ("SQLITE_CREATE_TEMP_TRIGGER", "create", "trigger"),
-    ("SQLITE_CREATE_TEMP_VIEW", "create", "view"),
-    ("SQLITE_DROP_TEMP_INDEX", "drop", "index"),
-    ("SQLITE_DROP_TEMP_TABLE", "drop", "table"),
-    ("SQLITE_DROP_TEMP_TRIGGER", "drop", "trigger"),
-    ("SQLITE_DROP_TEMP_VIEW", "drop", "view"),
-)
-for schema_action in _TEMP_SCHEMA_ACTIONS:
-    _add_schema_action(*schema_action)
-
-_VTABLE_SCHEMA_ACTIONS: tuple[
-    tuple[str, SQLSchemaOperation, SQLSchemaTargetType], ...
-] = (
-    ("SQLITE_CREATE_VTABLE", "create", "virtual-table"),
-    ("SQLITE_DROP_VTABLE", "drop", "virtual-table"),
-)
-for schema_action in _VTABLE_SCHEMA_ACTIONS:
-    _add_schema_action(*schema_action)
-
-_SQLITE_SCHEMA_TABLES = {
-    "sqlite_master",
-    "sqlite_schema",
-    "sqlite_temp_master",
-    "sqlite_temp_schema",
-}
-_SQLITE_INTERNAL_SCHEMA_FUNCTIONS = {
-    "length",
-    "like",
-    "printf",
-    "sqlite_drop_column",
-    "sqlite_rename_column",
-    "sqlite_rename_quotefix",
-    "sqlite_rename_table",
-    "sqlite_rename_test",
-    "substr",
-}
-
-_AUTHORIZER_ACTION_NAMES = {
-    getattr(sqlite3, name): name
-    for name in (
-        "SQLITE_CREATE_INDEX",
-        "SQLITE_CREATE_TABLE",
-        "SQLITE_CREATE_TEMP_INDEX",
-        "SQLITE_CREATE_TEMP_TABLE",
-        "SQLITE_CREATE_TEMP_TRIGGER",
-        "SQLITE_CREATE_TEMP_VIEW",
-        "SQLITE_CREATE_TRIGGER",
-        "SQLITE_CREATE_VIEW",
-        "SQLITE_DELETE",
-        "SQLITE_DROP_INDEX",
-        "SQLITE_DROP_TABLE",
-        "SQLITE_DROP_TEMP_INDEX",
-        "SQLITE_DROP_TEMP_TABLE",
-        "SQLITE_DROP_TEMP_TRIGGER",
-        "SQLITE_DROP_TEMP_VIEW",
-        "SQLITE_DROP_TRIGGER",
-        "SQLITE_DROP_VIEW",
-        "SQLITE_INSERT",
-        "SQLITE_PRAGMA",
-        "SQLITE_READ",
-        "SQLITE_SELECT",
-        "SQLITE_TRANSACTION",
-        "SQLITE_UPDATE",
-        "SQLITE_ATTACH",
-        "SQLITE_DETACH",
-        "SQLITE_ALTER_TABLE",
-        "SQLITE_REINDEX",
-        "SQLITE_ANALYZE",
-        "SQLITE_CREATE_VTABLE",
-        "SQLITE_DROP_VTABLE",
-        "SQLITE_FUNCTION",
-        "SQLITE_SAVEPOINT",
-        "SQLITE_RECURSIVE",
-    )
-    if hasattr(sqlite3, name)
-}
-
-
-def _allow_authorizer_action(*args):
-    return sqlite3.SQLITE_OK
-
-
-def analyze_sql_tables(
-    conn,
-    sql: str,
-    params=None,
-    *,
-    database_name: str | None = None,
-    schema_to_database: dict[str, str] | None = None,
-) -> SQLAnalysis:
-    """
-    Return operations performed by a SQL statement according to SQLite's authorizer.
-
-    This function is synchronous and connection-based. It temporarily installs a
-    SQLite authorizer, prepares ``EXPLAIN <sql>``, and returns the operation
-    callbacks observed while SQLite compiles the statement.
-    """
-    operations: dict[OperationKey, set[str]] = {}
-
-    def database_for_schema(sqlite_schema):
-        if schema_to_database and sqlite_schema in schema_to_database:
-            return schema_to_database[sqlite_schema]
-        if sqlite_schema == "main" and database_name is not None:
-            return database_name
-        return sqlite_schema
-
-    def record(
-        operation: SQLOperation,
-        target_type: SQLTargetType,
-        *,
-        database: str | None,
-        table: str | None,
-        sqlite_schema: str | None,
-        target: str | None,
-        source: str | None,
-        column: str | None = None,
-        internal: bool = False,
-    ):
-        key = OperationKey(
-            operation=operation,
-            target_type=target_type,
-            database=database,
-            table=table,
-            sqlite_schema=sqlite_schema,
-            target=target,
-            source=source,
-            internal=internal,
-        )
-        columns = operations.setdefault(key, set())
-        if column is not None:
-            columns.add(column)
-
-    def authorizer(action, arg1, arg2, sqlite_schema, source):
-        operation = _ACTION_TO_OPERATION.get(action)
-        if operation is not None and arg1 is not None:
-            target_type = "schema" if arg1 in _SQLITE_SCHEMA_TABLES else "table"
-            column = (
-                arg2 if operation in ("read", "update") and arg2 is not None else None
-            )
-            record(
-                operation,
-                target_type,
-                database=database_for_schema(sqlite_schema),
-                table=arg1 if target_type == "table" else None,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-                column=column,
-            )
-            return sqlite3.SQLITE_OK
-
-        create_operation = _CREATE_ACTIONS.get(action)
-        if create_operation is not None and arg1 is not None:
-            operation, target_type = create_operation
-            related_table = arg2 if target_type in {"index", "trigger"} else arg1
-            record(
-                operation,
-                target_type,
-                database=database_for_schema(sqlite_schema),
-                table=related_table,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        drop_operation = _DROP_ACTIONS.get(action)
-        if drop_operation is not None and arg1 is not None:
-            operation, target_type = drop_operation
-            related_table = arg2 if target_type in {"index", "trigger"} else arg1
-            record(
-                operation,
-                target_type,
-                database=database_for_schema(sqlite_schema),
-                table=related_table,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_ALTER_TABLE and arg2 is not None:
-            record(
-                "alter",
-                "table",
-                database=database_for_schema(arg1),
-                table=arg2,
-                sqlite_schema=arg1,
-                target=arg2,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_TRANSACTION and arg1 is not None:
-            record(
-                arg1.lower(),
-                "transaction",
-                database=None,
-                table=None,
-                sqlite_schema=None,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_ATTACH and arg1 is not None:
-            record(
-                "attach",
-                "database",
-                database=None,
-                table=None,
-                sqlite_schema=None,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_DETACH and arg1 is not None:
-            record(
-                "detach",
-                "database",
-                database=None,
-                table=None,
-                sqlite_schema=None,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_PRAGMA and arg1 is not None:
-            record(
-                "pragma",
-                "pragma",
-                database=None,
-                table=None,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_ANALYZE:
-            record(
-                "analyze",
-                "database" if arg1 is None else "table",
-                database=database_for_schema(sqlite_schema),
-                table=arg1,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_REINDEX and arg1 is not None:
-            record(
-                "reindex",
-                "index",
-                database=database_for_schema(sqlite_schema),
-                table=None,
-                sqlite_schema=sqlite_schema,
-                target=arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_SELECT:
-            record(
-                "select",
-                "statement",
-                database=None,
-                table=None,
-                sqlite_schema=sqlite_schema,
-                target=None,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_FUNCTION and arg2 is not None:
-            record(
-                "function",
-                "function",
-                database=None,
-                table=None,
-                sqlite_schema=sqlite_schema,
-                target=arg2,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        if action == sqlite3.SQLITE_SAVEPOINT and arg1 is not None:
-            record(
-                "savepoint",
-                "transaction",
-                database=None,
-                table=None,
-                sqlite_schema=sqlite_schema,
-                target="{} {}".format(arg1, arg2) if arg2 is not None else arg1,
-                source=source,
-            )
-            return sqlite3.SQLITE_OK
-
-        action_name = _AUTHORIZER_ACTION_NAMES.get(action, "SQLITE_{}".format(action))
-        record(
-            "unknown",
-            "unknown",
-            database=database_for_schema(sqlite_schema),
-            table=None,
-            sqlite_schema=sqlite_schema,
-            target=action_name,
-            source=source,
-        )
-        return sqlite3.SQLITE_OK
-
-    table_kind_cache: dict[tuple[str | None, str], SQLiteTableType | None] = {}
-
-    conn.set_authorizer(authorizer)
-    try:
-        explain_rows = conn.execute(
-            "EXPLAIN " + sql, params if params is not None else {}
-        ).fetchall()
-        # Passing None before these lookups leaves a failing callback installed
-        # on Python 3.10, so use a permissive callback until they are complete.
-        conn.set_authorizer(_allow_authorizer_action)
-
-        if not operations:
-            vacuum_row = next((row for row in explain_rows if row[1] == "Vacuum"), None)
-            if vacuum_row is not None:
-                schema_by_index = {
-                    row[0]: row[1] for row in conn.execute("PRAGMA database_list")
-                }
-                sqlite_schema = schema_by_index.get(vacuum_row[2])
-                database = database_for_schema(sqlite_schema)
-                record(
-                    "vacuum",
-                    "database",
-                    database=database,
-                    table=None,
-                    sqlite_schema=sqlite_schema,
-                    target=database,
-                    source=None,
-                )
-            else:
-                record(
-                    "unknown",
-                    "statement",
-                    database=database_name,
-                    table=None,
-                    sqlite_schema=None,
-                    target=None,
-                    source=None,
-                )
-
-        for key in operations:
-            if (
-                key.target_type == "table"
-                and key.operation in {"read", "insert", "update", "delete"}
-                and key.table is not None
-            ):
-                cache_key = (key.sqlite_schema, key.table)
-                if cache_key not in table_kind_cache:
-                    table_kind_cache[cache_key] = sqlite_table_type(
-                        conn, key.table, schema=key.sqlite_schema
-                    )
-    finally:
-        conn.set_authorizer(None)
-
-    has_schema_operation = any(
-        key.target_type in {"table", "index", "view", "trigger", "virtual-table"}
-        and key.operation in {"create", "alter", "drop"}
-        for key in operations
-    )
-    dropped_tables = {
-        (key.database, key.table)
-        for key in operations
-        if key.operation == "drop" and key.target_type == "table"
-    }
-
-    def key_is_drop_table_delete(key: OperationKey) -> bool:
-        return (
-            key.operation == "delete"
-            and key.target_type == "table"
-            and (key.database, key.table) in dropped_tables
-        )
-
-    has_user_table_access_in_schema_operation = any(
-        key.operation in {"read", "insert", "update", "delete"}
-        and key.target_type == "table"
-        and not key.internal
-        and not key_is_drop_table_delete(key)
-        for key in operations
-    )
-
-    def operation_is_internal(key: OperationKey) -> bool:
-        if key.internal or (has_schema_operation and key.target_type == "schema"):
-            return True
-        if has_schema_operation and key.operation == "reindex":
-            return True
-        if (
-            has_schema_operation
-            and not has_user_table_access_in_schema_operation
-            and key.operation == "function"
-            and key.target in _SQLITE_INTERNAL_SCHEMA_FUNCTIONS
-        ):
-            return True
-        if key_is_drop_table_delete(key):
-            return True
-        return False
-
-    def table_kind_for(key: OperationKey) -> SQLiteTableType | None:
-        if (
-            key.target_type != "table"
-            or key.operation not in {"read", "insert", "update", "delete"}
-            or key.table is None
-        ):
-            return None
-        return table_kind_cache[(key.sqlite_schema, key.table)]
-
-    return SQLAnalysis(
-        operations=tuple(
-            Operation(
-                operation=key.operation,
-                target_type=key.target_type,
-                database=key.database,
-                table=key.table,
-                sqlite_schema=key.sqlite_schema,
-                table_kind=table_kind_for(key),
-                target=key.target,
-                columns=tuple(sorted(columns)),
-                source=key.source,
-                internal=operation_is_internal(key),
-            )
-            for key, columns in operations.items()
-        )
-    )

datasette/utils/sqlite.py

@@ -1,6 +1,3 @@
-import re
-from typing import Literal
-
 using_pysqlite3 = False
 try:
     import pysqlite3 as sqlite3
@@ -13,18 +10,6 @@ if hasattr(sqlite3, "enable_callback_tracebacks"):
     sqlite3.enable_callback_tracebacks(True)
 
 _cached_sqlite_version = None
-SQLiteTableType = Literal["table", "view", "virtual", "shadow"]
-_VIRTUAL_TABLE_MODULE_RE = re.compile(
-    r"\bCREATE\s+VIRTUAL\s+TABLE\b.*?\bUSING\s+([^\s(]+)",
-    re.IGNORECASE | re.DOTALL,
-)
-_VIRTUAL_TABLE_SHADOW_SUFFIXES = {
-    "fts3": ("_content", "_segdir", "_segments", "_stat", "_docsize"),
-    "fts4": ("_content", "_segdir", "_segments", "_stat", "_docsize"),
-    "fts5": ("_data", "_idx", "_docsize", "_content", "_config"),
-    "rtree": ("_node", "_parent", "_rowid"),
-    "rtree_i32": ("_node", "_parent", "_rowid"),
-}
 
 
 def sqlite_version():
@@ -35,147 +20,20 @@ def sqlite_version():
 
 
 def _sqlite_version():
-    conn = sqlite3.connect(":memory:")
-    try:
-        return tuple(
-            map(
-                int,
-                conn.execute("select sqlite_version()").fetchone()[0].split("."),
-            )
+    return tuple(
+        map(
+            int,
+            sqlite3.connect(":memory:")
+            .execute("select sqlite_version()")
+            .fetchone()[0]
+            .split("."),
         )
-    finally:
-        conn.close()
+    )
 
 
 def supports_table_xinfo():
     return sqlite_version() >= (3, 26, 0)
 
 
-def supports_table_list():
-    return sqlite_version() >= (3, 37, 0)
-
-
 def supports_generated_columns():
     return sqlite_version() >= (3, 31, 0)
-
-
-def sqlite_table_type(
-    conn,
-    table: str,
-    *,
-    schema: str | None = "main",
-) -> SQLiteTableType | None:
-    if supports_table_list():
-        try:
-            query = "select type from pragma_table_list where name = ?"
-            params: tuple[str, ...] = (table,)
-            if schema is not None:
-                query += " and schema = ?"
-                params = (table, schema)
-            row = conn.execute(query, params).fetchone()
-            if row is not None and row[0] in {"table", "view", "virtual", "shadow"}:
-                return row[0]
-        except sqlite3.DatabaseError:
-            pass
-    return _sqlite_table_type_from_schema(conn, table, schema=schema)
-
-
-def sqlite_hidden_table_names(conn, *, schema: str | None = "main") -> list[str]:
-    schema_table = _sqlite_schema_table(schema)
-    try:
-        rows = conn.execute(
-            "select name, sql from {} where type = 'table'".format(schema_table)
-        ).fetchall()
-    except sqlite3.DatabaseError:
-        return []
-    hidden_tables = []
-    content_fts_tables = []
-    for name, sql in rows:
-        if (
-            name in {"sqlite_stat1", "sqlite_stat2", "sqlite_stat3", "sqlite_stat4"}
-            or name.startswith("_")
-            or sqlite_table_type(conn, name, schema=schema) == "shadow"
-        ):
-            hidden_tables.append(name)
-        elif _is_fts_content_virtual_table(sql):
-            content_fts_tables.append(name)
-    return sorted(hidden_tables) + content_fts_tables
-
-
-def _sqlite_table_type_from_schema(
-    conn,
-    table: str,
-    *,
-    schema: str | None = "main",
-) -> SQLiteTableType | None:
-    schema_table = _sqlite_schema_table(schema)
-    try:
-        row = conn.execute(
-            "select type, sql from {} where name = ?".format(schema_table),
-            (table,),
-        ).fetchone()
-    except sqlite3.DatabaseError:
-        return None
-    if row is None:
-        return None
-    object_type, sql = row
-    if object_type == "view":
-        return "view"
-    if object_type != "table":
-        return None
-    if _virtual_table_module(sql) is not None:
-        return "virtual"
-    if _is_known_shadow_table(conn, table, schema=schema):
-        return "shadow"
-    return "table"
-
-
-def _is_known_shadow_table(
-    conn,
-    table: str,
-    *,
-    schema: str | None = "main",
-) -> bool:
-    schema_table = _sqlite_schema_table(schema)
-    try:
-        rows = conn.execute(
-            "select name, sql from {} where type = 'table'".format(schema_table)
-        ).fetchall()
-    except sqlite3.DatabaseError:
-        return False
-    for virtual_table, sql in rows:
-        module = _virtual_table_module(sql)
-        if module is None:
-            continue
-        for suffix in _VIRTUAL_TABLE_SHADOW_SUFFIXES.get(module, ()):
-            if table == virtual_table + suffix:
-                return True
-    return False
-
-
-def _sqlite_schema_table(schema: str | None) -> str:
-    if schema is None or schema == "main":
-        return "sqlite_master"
-    if schema == "temp":
-        return "sqlite_temp_master"
-    return "{}.sqlite_master".format(_quote_identifier(schema))
-
-
-def _quote_identifier(value: str) -> str:
-    return '"{}"'.format(value.replace('"', '""'))
-
-
-def _virtual_table_module(sql: str | None) -> str | None:
-    if not sql:
-        return None
-    match = _VIRTUAL_TABLE_MODULE_RE.search(sql)
-    if match is None:
-        return None
-    return match.group(1).strip("\"'[]`").lower()
-
-
-def _is_fts_content_virtual_table(sql: str | None) -> bool:
-    return (
-        _virtual_table_module(sql) in {"fts3", "fts4", "fts5"}
-        and "content=" in sql.lower()
-    )

datasette/utils/testing.py

@@ -95,8 +95,15 @@ class TestClient:
         cookies = cookies or {}
         post_data = post_data or {}
         assert not (post_data and body), "Provide one or other of body= or post_data="
-        # csrftoken_from is accepted for backward compatibility but is now a no-op.
-        # Datasette no longer uses CSRF tokens - see CrossOriginProtectionMiddleware.
+        # Maybe fetch a csrftoken first
+        if csrftoken_from is not None:
+            assert body is None, "body= is not compatible with csrftoken_from="
+            if csrftoken_from is True:
+                csrftoken_from = path
+            token_response = await self._request(csrftoken_from, cookies=cookies)
+            csrftoken = token_response.cookies["ds_csrftoken"]
+            cookies["ds_csrftoken"] = csrftoken
+            post_data["csrftoken"] = csrftoken
         if post_data:
             body = urlencode(post_data, doseq=True)
         return await self._request(

datasette/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.0a31"
+__version__ = "1.0a19"
 __version_info__ = tuple(__version__.split("."))