Next (#364)

Reviewed-on: #364

.dockerignore

@@ -3,8 +3,10 @@
 # stage of the Dockerfile.
 .git/
 bin/
-# Extracted from 3p/ by `make assets` inside the build; a host copy is not
+# Third-party browser assets are fetched and hash-verified inside the build by
-# needed. The tarball in 3p/ must stay in the context.
+# script/fetch-assets. Excluding any host copy keeps a developer's working tree
+# from supplying the bytes that get shipped. The script and its
+# static/vendor.sha256 manifest stay in the context.
 static/js/alpine.min.js
 *.md
 LICENSE

.gitignore

@@ -46,6 +46,7 @@ temp/
 # CI cache barrier, written into the build context by the check workflow
 .ci-fingerprint
 
-# Alpine.js, extracted by `make assets` from its tarball in 3p/, which is
+# Third-party browser assets, fetched and hash-verified by
-# what is committed.
+# script/fetch-assets against static/vendor.sha256. Not committed:
-/static/js/alpine.min.js
+# REPO_POLICIES.md forbids minified bundles in version control.
+/static/js/alpine.min.js 

Dockerfile

@@ -51,8 +51,15 @@ RUN go mod download
 # the lint stage above.
 COPY . .
 
-# Run tests and build. Both first run script/assets, which extracts Alpine.js
+# Fetch the third-party browser assets the UI serves. They are not committed
-# from its tarball in 3p/.
+# (REPO_POLICIES.md forbids minified bundles in version control) and
+# .dockerignore keeps any host copy out of the build context, so this step is
+# the only way they enter the image. Each download is checked against a
+# hardcoded sha256 and the build fails on mismatch; make test re-checks the
+# hashes against the bytes go:embed actually put in the binary.
+RUN script/fetch-assets
+
+# Run tests and build
 RUN make test
 
 # Version stamped into the binary. .dockerignore excludes .git/, so
@@ -60,8 +67,8 @@ RUN make test
 # host and passes it in. The default is what a bare `docker build .`
 # with no --build-arg gets, and it names no tag the tree may not be at.
 #
-# Declared here, below the test step, so a changed version does not
+# Declared here, below the test and asset steps, so a changed version
-# invalidate its cached layer.
+# does not invalidate their cached layers.
 ARG VERSION=unknown
 
 RUN make build VERSION="$VERSION"

Makefile

@@ -28,7 +28,7 @@ setup:
 	@script/setup
 
 assets:
-	@script/assets
+	@script/fetch-assets
 
 test:
 	@script/test
@@ -45,13 +45,13 @@ fmt-check:
 check:
 	@script/check
 
-build: assets
+build:
 	go build -ldflags '$(strip -X main.version=$(VERSION) $(GO_LDFLAGS))' -o bin/webhooker ./cmd/webhooker
 
 run: build
 	./bin/webhooker
 
-dev: assets
+dev:
 	go run ./cmd/webhooker
 
 deps:

README.md

@@ -21,6 +21,9 @@ before deploying one.
 - Go 1.26.1+ (the version in `go.mod`)
 - Docker (for linting, for the test stage of the CI gate, and for
   containerized deployment)
+- `curl`, used by `script/fetch-assets` to download the third-party
+  browser assets, which are not committed (`make bootstrap` installs
+  it if missing)
 
 golangci-lint is not a prerequisite and must not be installed on the
 host: `script/bootstrap` does not install it, and `make lint` runs the
@@ -33,7 +36,9 @@ digest-pinned linter image via `Dockerfile.lint`.
 git clone https://git.eeqj.de/sneak/webhooker.git
 cd webhooker
 
-# Install the Go toolchain if missing, and the Go dependencies
+# Install Go dependencies and the third-party browser assets.
+# `make deps` alone is not enough: it only runs go mod download/tidy,
+# and the checks below need the fetched assets.
 make bootstrap
 
 # Run all checks (test, lint, format check)
@@ -53,7 +58,7 @@ make docker
 ```bash
 make bootstrap  # Install all dependencies (idempotent)
 make setup      # Bootstrap + install git pre-commit hook
-make assets     # Extract Alpine.js from 3p/ (test, check, build, dev run it)
+make assets     # Fetch + verify third-party browser assets
 make fmt        # Format code (gofmt + goimports)
 make fmt-check  # Fail if gofmt would change anything (writes nothing)
 make lint       # Run golangci-lint in Docker (Dockerfile.lint)
@@ -1065,7 +1070,7 @@ unconditionally against whatever files it finds:
 - the main database on connect — `Setting`, `User`, `APIKey`, `Webhook`,
   `Entrypoint`, `Target`
 - each event database when it is lazily opened — `Event`, `Delivery`,
-  `DeliveryResult`, `EventTotals`, `TargetTotals`
+  `DeliveryResult`
 - each archive database on every open and reopen
 
 There is no schema version table, no migration ledger, and no down
@@ -1216,15 +1221,14 @@ This repository adheres to the
 standard: normalized scripts in `script/` are the entrypoints for the
 development workflow. Ten of the Makefile's seventeen targets are thin
 shims that call them; `build`, `run`, `dev`, `deps`, `clean`, `css` and
-`version` are inline commands with no script behind them, though `build`,
+`version` are inline commands with no script behind them, though
-`run` and `dev` first run `script/assets`, and `build` and `version` both
+`build` and `version` both take their value from `script/version`.
-take their value from `script/version`.
 
-`script/test`, `make build` and `make dev` each run `script/assets`
+`make check` needs the third-party browser assets in `static/`, which
-first, which writes the ignored `static/js/alpine.min.js` (see
+are not committed, so run `make bootstrap` (or just `make assets`) once
-[Third-party browser assets](#third-party-browser-assets)), so
+after cloning. Without them the tests fail with a message naming that
-`make test`, `make check` and the pre-commit hook work on a fresh clone
+remedy. `make check` does not fetch them itself because it must not
-without a separate step.
+change any files in the repo.
 
 We provide:
 
@@ -1232,8 +1236,8 @@ We provide:
 - `script/setup` — make a fresh clone ready for development
   (bootstrap, then install-precommit)
 - `script/projectname` — output the project name ("webhooker")
-- `script/assets` — extract Alpine.js from its tarball in `3p/` (see
+- `script/fetch-assets` — download the third-party browser assets into
-  [Third-party browser assets](#third-party-browser-assets))
+  `static/`, verifying each against its pinned sha256
 - `script/test` — run the test suite
 - `script/lint` — run golangci-lint in Docker (see Linting below)
 - `script/fmt` — format all code (writes)
@@ -1255,25 +1259,24 @@ We provide:
 
 ## Third-party browser assets
 
-The web UI serves one third-party script, Alpine.js. Its npm package tarball
+The web UI serves one third-party script, Alpine.js. It is **not** committed:
-is committed as `3p/alpinejs-3.14.9.tgz`, byte for byte as the npm registry
+a minified bundle in the tree is unreviewable, and `REPO_POLICIES.md` bars
-publishes it. It is a dependency, not this repo's build output, so
+both committed build artifacts and unpinned external references.
-`REPO_POLICIES.md`'s rule against committed build artifacts does not apply.
-The directory is `3p/` rather than `vendor/` because Go treats a root
-`vendor/` directory as its module vendor directory.
 
-`script/assets` (`make assets`) extracts the browser build,
+Instead `script/fetch-assets` downloads it from a pinned URL, checks the
-`package/dist/cdn.min.js`, from the tarball to `static/js/alpine.min.js`,
+download against a hardcoded sha256, and installs it under `static/`. The
-where `go:embed` picks it up. `script/test`, `make build` and `make dev` run
+sha256 of every installed asset is recorded in `static/vendor.sha256`, and
-it first, and the Dockerfile builds through `make test` and `make build`, so
+`static/vendor_test.go` re-hashes the bytes `go:embed` put in the binary
-nothing downloads Alpine.js. The extracted file is not committed, and
+against that manifest — so the pin is enforced on what actually ships, not
-`.dockerignore` keeps any host copy out of the build context.
+merely written down. Any mismatch fails the build.
 
-To move to a new version: download
+`make bootstrap` runs the fetch for local development, and the Dockerfile
-`https://registry.npmjs.org/alpinejs/-/alpinejs-<version>.tgz`, check it
+runs it in the build stage; `.gitignore` and `.dockerignore` keep the
-against the `dist.integrity` hash listed at
+artifact out of both the repo and the build context.
-`https://registry.npmjs.org/alpinejs/<version>`, replace the tarball in `3p/`
+
-with it, update its file name in `script/assets`, and run `make check`.
+To move to a new version: update the version, URL, and tarball sha256 in
+`script/fetch-assets` and the asset sha256 in `static/vendor.sha256`, then
+run `make assets && make check`.
 
 ## Rationale
 
@@ -1381,7 +1384,7 @@ The codebase uses consistent naming throughout (rename completed in
 
 ### Data Model
 
-webhooker's data model has eleven entities organized into two tiers: the
+webhooker's data model has nine entities organized into two tiers: the
 **application tier** (user and webhook configuration) and the **event
 tier** (event ingestion, delivery, and logging).
 
@@ -1410,13 +1413,6 @@ tier** (event ingestion, delivery, and logging).
 │  ┌──────────┐       ┌──────────┐       ┌─────────────────┐  │
 │  │  Event   │──1:N──│ Delivery │──1:N──│ DeliveryResult  │  │
 │  └──────────┘       └──────────┘       └─────────────────┘  │
-│                                                             │
-│  ┌──────────────┐  (one row: running counts of events)      │
-│  │ EventTotals  │                                           │
-│  └──────────────┘                                           │
-│  ┌──────────────┐  (one row per target: running counts      │
-│  │ TargetTotals │   of its deliveries)                      │
-│  └──────────────┘                                           │
 └─────────────────────────────────────────────────────────────┘
 ```
 
@@ -1443,7 +1439,7 @@ A registered user of the webhooker service.
 | Field      | Type     | Description |
 | ---------- | -------- | ----------- |
 | `id`       | UUID     | Primary key |
-| `username` | string   | Unique login name, at most 1024 bytes so that it fits in the session cookie |
+| `username` | string   | Unique login name |
 | `password` | string   | Argon2id hash (never exposed via API) |
 
 **Relations:** Has many Webhooks. Has many APIKeys.
@@ -1669,7 +1665,6 @@ status across potentially multiple attempts.
 | `event_id` | UUID           | Foreign key → Event |
 | `target_id`| UUID           | Foreign key → Target |
 | `status`   | DeliveryStatus | One of: `pending`, `delivered`, `failed`, `retrying` |
-| `finished_at` | timestamp   | When the delivery became `delivered` or `failed` (nullable; empty while `pending` or `retrying`) |
 
 **Relations:** Belongs to Event. Belongs to Target. Has many
 DeliveryResults.
@@ -1737,65 +1732,33 @@ retries) is individually logged for full observability.
 
 **Relations:** Belongs to Delivery.
 
-#### EventTotals and TargetTotals
-
-Running counts in each event database, read by the statistics pane at the
-top of the webhook page. `EventTotals` is one row:
-
-| Field            | Type    | Description |
-| ---------------- | ------- | ----------- |
-| `events`         | integer | Events ever stored, resubmitted copies included |
-| `events_removed` | integer | Events retention has deleted |
-
-`TargetTotals` is one row per target, created by the first delivery to it:
-
-| Field                | Type    | Description |
-| -------------------- | ------- | ----------- |
-| `target_id`          | UUID    | The target (primary key) |
-| `deliveries`         | integer | Deliveries to it ever created, replays included |
-| `delivered`          | integer | Of those, how many became `delivered` |
-| `failed`             | integer | Of those, how many became `failed` |
-| `deliveries_removed` | integer | Its deliveries retention has deleted |
-| `failed_removed`     | integer | Its failed deliveries retention has deleted |
-
-Each count changes in the transaction that writes or deletes the rows it
-counts. The pane's lifetime events are `events`, and its lifetime
-deliveries and failures are `deliveries` and `failed` summed over the
-targets; each figure within retention is the same less what retention
-removed, so neither needs the rows themselves. Its last-10-minutes and
-last-24-hours figures are counted from the `events` and `deliveries`
-indexes over just that window, the deliveries in one query grouped by
-target. Its failure percentage for a window is the deliveries that became
-`failed` in it out of all that became `delivered` or `failed` in it, and
-a dash when none did.
-
 #### Event-tier indexes
 
 These indexes on the per-webhook event databases are declared in the model
-tags, so `AutoMigrate` creates them on a fresh database:
+tags, so `AutoMigrate` creates them on a fresh and on an existing database:
 
 | Table              | Columns                     | Serves |
 | ------------------ | --------------------------- | ------ |
-| `deliveries`       | `status`, `deleted_at`, `finished_at`, `target_id` | Startup recovery, the retry and pending sweeps every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status, and the webhook page's statistics, which count each target's deliveries by status and when they finished |
+| `deliveries`       | `status`, `deleted_at`      | Startup recovery, the retry and pending sweeps every 60 seconds and the queue-depth sampler every 30 seconds, which select deliveries by status |
-| `deliveries`       | `event_id`, `deleted_at`    | The event log, which loads each event's deliveries, and retention, which counts and deletes the deliveries of expired events |
+| `deliveries`       | `event_id`, `deleted_at`    | The event log, which loads each event's deliveries, and retention, which selects and deletes the deliveries of expired events |
 | `delivery_results` | `delivery_id`, `deleted_at` | The event log, which loads the attempts of a page's deliveries, and retention, which deletes the attempts of expired events |
-| `events`           | `deleted_at`, `created_at`  | The webhook page's statistics, which count recent events and find the newest |
+| `events`           | `deleted_at`, `created_at`  | Retention, which selects expired events by age |
-| `events`           | `created_at`                | Retention, which selects expired events by age |
+| `events`           | `created_at`                | Retention's delete of the expired events themselves |
 
-GORM's soft delete adds `deleted_at IS NULL` to these queries; retention
+GORM's soft delete adds `deleted_at IS NULL` to these queries; retention's
-leaves it out. SQLite keeps no statistics on these tables, and without them it
+deletes leave it out, but their lookups of expired rows keep it. SQLite keeps
-rates the `deleted_at` index, which every live row matches, above an index on
+no statistics on these tables, and without them it rates the `deleted_at`
-a column matched against several values or compared with `<`. So every index
+index, which every live row matches, above an index on a column matched
-but the last also covers `deleted_at`. It comes second, so that retention can
+against several values or compared with `<`. So every index but the last also
-use the index without it, except in `events`, where `created_at` is compared
+covers `deleted_at`. It comes second, so that retention's deletes can use the
-with `<` and SQLite narrows by a `<` only on the last column it uses.
+index without it, except in `events`, where `created_at` is compared with `<`
+and SQLite narrows by a `<` only on the last column it uses.
 
 #### Common Fields
 
-Every entity except `Setting`, `EventTotals` and `TargetTotals` includes
+Every entity except `Setting` includes these fields from `BaseModel`.
-these fields from `BaseModel`. `Setting` is a bare key-value row with no
+`Setting` is a bare key-value row with no `id`, no timestamps and no
-`id`, no timestamps and no soft delete, and the two totals tables hold
+soft delete:
-only counts, keyed by a numeric `id` and by `target_id`:
 
 | Field        | Type      | Description |
 | ------------ | --------- | ----------- |
@@ -1837,8 +1800,6 @@ encryption key is generated and stored, and an `admin` user is created.
 - **Events** — captured incoming webhook payloads
 - **Deliveries** — event-to-target pairings and their status
 - **DeliveryResults** — individual delivery attempt logs
-- **EventTotals** and **TargetTotals** — running counts of the above,
-  the deliveries per target, kept through retention
 
 Per-webhook databases are created automatically when a webhook is
 created (and lazily on first access for webhooks that predate this
@@ -2418,14 +2379,14 @@ Removing either cap fails 14 subtests.
 
 `internal/middleware/logbound_test.go` and
 `internal/handlers/logbound_test.go` drive 8 KB of client-chosen text
-at each of these — just under 1 KB at `invalid password`, whose
+at each of these — 1 KB at `invalid password`, whose accounts are
-accounts are shared with the successful-login line and so must stay
+shared with the successful-login line, where a username past 4 KB
-within the 1024-byte username limit — through both handlers, and
+overflows the session cookie and answers 500 before that line is
-through seven fills: plain text as the baseline, and then the
+written — through both handlers, and through seven fills: plain text
-quotation mark, backslash, tab, newline, C0 control and astral
+as the baseline, and then the quotation mark, backslash, tab, newline,
-non-printable, six characters the wider of the two handlers spends
+C0 control and astral non-printable, six characters the wider of the
-more on than the client spent sending them. Every case holds each
+two handlers spends more on than the client spent sending them. Every
-line to the 2,560-byte ceiling. That per-line ceiling
+case holds each line to the 2,560-byte ceiling. That per-line ceiling
 is what the figure above states, and every row establishes it.
 
 Three of the sites go further and bound the whole flood's output — the
@@ -2794,8 +2755,6 @@ imports. The entry point is `cmd/webhooker/main.go`.
 
 ```
 webhooker/
-├── 3p/
-│   └── alpinejs-3.14.9.tgz    # Alpine.js npm package, extracted by make assets
 ├── cmd/webhooker/
 │   └── main.go               # Entry point: subcommand dispatch; no args locks DATA_DIR and wires fx
 ├── internal/
@@ -2819,7 +2778,6 @@ webhooker/
 │   │   ├── model_event.go     # Event entity (per-webhook DB)
 │   │   ├── model_delivery.go  # Delivery entity (per-webhook DB)
 │   │   ├── model_delivery_result.go  # DeliveryResult entity (per-webhook DB)
-│   │   ├── model_totals.go    # EventTotals and TargetTotals (per-webhook DB)
 │   │   ├── model_apikey.go    # APIKey entity
 │   │   ├── password.go        # Argon2id hashing and verification
 │   │   ├── retention.go       # Retention reaper (per-webhook event expiry)
@@ -2890,7 +2848,8 @@ webhooker/
 │   ├── css/tailwind.css       # Generated stylesheet the pages load
 │   ├── css/style.css          # Older hand-written stylesheet, no longer loaded
 │   ├── js/app.js              # Progressive-enhancement copy-to-clipboard
-│   └── js/alpine.min.js       # Alpine.js, extracted from 3p/ by make assets, not committed
+│   ├── js/alpine.min.js       # Alpine.js, fetched by script/fetch-assets, not committed
+│   └── vendor.sha256          # Pinned hashes the fetched assets are verified against
 ├── templates/                 # Go HTML templates (base, login, sources, etc.)
 ├── script/                    # Scripts to Rule Them All entrypoints
 ├── Dockerfile                 # Three stages: lint, test+build, Alpine runtime
@@ -3202,14 +3161,14 @@ version is fixed independently of the compiler's:
    `make fmt-check`, then `golangci-lint config verify` and
    `golangci-lint run`, both with `--network=none`.
 2. **Builder stage** (`golang:1.26.1-bookworm`) — depends on the lint
-   stage passing (it copies a file from it), runs `make test` and
+   stage passing (it copies a file from it), runs `script/fetch-assets`
-   `make build` (both extract Alpine.js from `3p/` first), and finally
+   to download and verify the third-party browser assets, then runs
-   rebuilds the binary with `CGO_ENABLED=1` and static linking so it
+   `make test` and `make build`, and finally rebuilds the binary with
-   runs on musl. Both builds go through `make build`, the relink adding
+   `CGO_ENABLED=1` and static linking so it runs on musl. Both builds
-   its `-extldflags` via `GO_LDFLAGS`, so neither can drop the `-X` that
+   go through `make build`, the relink adding its `-extldflags` via
-   stamps the version. The version arrives as the `VERSION` build arg,
+   `GO_LDFLAGS`, so neither can drop the `-X` that stamps the version.
-   since the context has no `.git` (see
+   The version arrives as the `VERSION` build arg, since the context
-   [Version stamping](#version-stamping)).
+   has no `.git` (see [Version stamping](#version-stamping)).
 3. **Runtime stage** (`alpine:3.21`) — copies the static binary and
    `deploy/docker-entrypoint.sh`, creates the `/var/lib/webhooker`
    directory for all SQLite databases, exposes port 8080, and includes

internal/database/event_tier_indexes_test.go

@@ -93,11 +93,11 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		deliveries []database.Delivery
 		results    []database.DeliveryResult
 		depths     []struct{ Depth int }
-		removed    []database.TargetTotals
 	)
 
 	byStatus := "idx_deliveries_status (status=? AND deleted_at=?)"
 	byEvent := "idx_deliveries_event_id (event_id=? AND deleted_at=?)"
+	byAge := "idx_events_deleted_at_created_at (deleted_at=? AND created_at<?)"
 
 	// The delivery engine: recovery and the retry sweep, the sweep for
 	// stranded pending deliveries, and the queue depth count.
@@ -123,89 +123,25 @@ func TestEventTierQueriesUseTheirIndexes(t *testing.T) {
 		Order("attempt_num ASC").Find(&results),
 		"idx_delivery_results_delivery_id (delivery_id=? AND deleted_at=?)")
 
-	// Retention (reapExpired, deleteEvents): one batch of expired
+	// Retention's three deletes (reapExpired), whose subqueries are built
-	// events, then their attempts, deliveries and the events.
+	// afresh for each statement as it builds them.
-	var expired []string
+	expiredEventIDs := func() *gorm.DB {
+		return dry.Model(&database.Event{}).Select("id").
+			Where("created_at < ?", cutoff)
+	}
 
-	assertPlanUses(t, db, dry.Unscoped().Model(&database.Event{}).
-		Where("created_at < ?", cutoff).
-		Limit(database.ExportReapBatchSize).Pluck("id", &expired),
-		"idx_events_created_at (created_at<?)")
 	assertPlanUses(t, db, dry.Unscoped().Where(
-		"delivery_id IN (?)", dry.Unscoped().Model(&database.Delivery{}).
+		"delivery_id IN (?)", dry.Model(&database.Delivery{}).
-			Select("id").Where("event_id IN ?", ids),
+			Select("id").Where("event_id IN (?)", expiredEventIDs()),
 	).Delete(&database.DeliveryResult{}),
-		"idx_delivery_results_delivery_id (delivery_id=?)",
+		"idx_delivery_results_delivery_id (delivery_id=?)", byEvent, byAge)
-		"idx_deliveries_event_id (event_id=?)")
+	assertPlanUses(t, db, dry.Unscoped().Where(
-	assertPlanUses(t, db, dry.Unscoped().Model(&database.Delivery{}).
+		"event_id IN (?)", expiredEventIDs(),
-		Select("target_id, count(*) AS deliveries_removed, "+
+	).Delete(&database.Delivery{}),
-			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
+		"idx_deliveries_event_id (event_id=?)", byAge)
-			database.DeliveryStatusFailed).
+	assertPlanUses(t, db, dry.Unscoped().Where(
-		Where("event_id IN ?", ids).Group("target_id").Find(&removed),
+		"created_at < ?", cutoff,
-		"idx_deliveries_event_id (event_id=?)")
+	).Delete(&database.Event{}), "idx_events_created_at (created_at<?)")
-	assertPlanUses(t, db, dry.Unscoped().Where("event_id IN ?", ids).
-		Delete(&database.Delivery{}), "idx_deliveries_event_id (event_id=?)")
-	assertPlanUses(t, db, dry.Unscoped().Where("id IN ?", ids).
-		Delete(&database.Event{}), "sqlite_autoindex_events_1 (id=?)")
-}
-
-// TestStatisticsQueriesUseTheirIndexes does the same for the webhook
-// page's statistics (readEventStats in the handlers): deliveries in
-// progress, each target's deliveries finished since a time, which must
-// come from the index alone, events received since a time, and the
-// newest event, which must come straight off an index rather than from
-// sorting every event.
-func TestStatisticsQueriesUseTheirIndexes(t *testing.T) {
-	t.Parallel()
-
-	mgr, lc := setupTestWebhookDBManager(t)
-	ctx := context.Background()
-	require.NoError(t, lc.Start(ctx))
-
-	defer func() { require.NoError(t, lc.Stop(ctx)) }()
-
-	db, err := mgr.GetDB(uuid.New().String())
-	require.NoError(t, err)
-
-	dry := db.Session(&gorm.Session{DryRun: true})
-	since := time.Now()
-
-	var (
-		count    int64
-		newest   []time.Time
-		byTarget []struct{ TargetID string }
-	)
-
-	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
-		Where("status IN ?", []database.DeliveryStatus{
-			database.DeliveryStatusPending,
-			database.DeliveryStatusRetrying,
-		}).Count(&count),
-		"idx_deliveries_status (status=? AND deleted_at=?)")
-	assertPlanUses(t, db, dry.Model(&database.Delivery{}).
-		Select("target_id, "+
-			"count(CASE WHEN status = ? THEN 1 END) AS delivered, "+
-			"count(CASE WHEN status = ? THEN 1 END) AS failed",
-			database.DeliveryStatusDelivered,
-			database.DeliveryStatusFailed).
-		Where("status IN ? AND finished_at >= ?",
-			[]database.DeliveryStatus{
-				database.DeliveryStatusDelivered,
-				database.DeliveryStatusFailed,
-			}, since).
-		Group("target_id").Find(&byTarget),
-		"COVERING INDEX idx_deliveries_status "+
-			"(status=? AND deleted_at=? AND finished_at>?)")
-	assertPlanUses(t, db, dry.Model(&database.Event{}).
-		Where("created_at >= ?", since).Count(&count),
-		"idx_events_deleted_at_created_at "+
-			"(deleted_at=? AND created_at>?)")
-
-	newestEvent := dry.Model(&database.Event{}).
-		Order("created_at DESC").Limit(1).Pluck("created_at", &newest)
-	assertPlanUses(t, db, newestEvent,
-		"idx_events_deleted_at_created_at (deleted_at=?)")
-	assert.NotContains(t, queryPlan(t, db, newestEvent), "TEMP B-TREE")
 }
 
 // assertPlanUses asserts that SQLite's plan for a statement GORM built
@@ -216,18 +152,6 @@ func assertPlanUses(
 ) {
 	t.Helper()
 
-	plan := queryPlan(t, db, built)
-
-	for _, index := range indexes {
-		assert.Contains(t, plan, index, built.Statement.SQL.String())
-	}
-}
-
-// queryPlan returns SQLite's plan for a statement GORM built in a dry
-// run, run with the same SQL and arguments GORM would send.
-func queryPlan(t *testing.T, db, built *gorm.DB) string {
-	t.Helper()
-
 	var plan []struct{ Detail string }
 
 	require.NoError(t, db.Raw(
@@ -235,5 +159,8 @@ func queryPlan(t *testing.T, db, built *gorm.DB) string {
 		built.Statement.Vars...,
 	).Scan(&plan).Error)
 
-	return fmt.Sprint(plan)
+	for _, index := range indexes {
+		assert.Contains(t, fmt.Sprint(plan), index,
+			built.Statement.SQL.String())
+	}
 }

internal/database/export_test.go

@@ -28,10 +28,6 @@ func NewTestRetentionReaper(
 	}
 }
 
-// ExportReapBatchSize exposes how many expired events one retention
-// transaction deletes.
-const ExportReapBatchSize = reapBatchSize
-
 // ExportSweep runs a single retention sweep synchronously for tests.
 func (r *RetentionReaper) ExportSweep(ctx context.Context) {
 	r.sweep(ctx)

internal/database/model_delivery.go

@@ -1,10 +1,6 @@
 package database
 
-import (
+import "gorm.io/gorm"
-	"time"
-
-	"gorm.io/gorm"
-)
 
 // DeliveryStatus represents the status of a delivery
 type DeliveryStatus string
@@ -41,7 +37,7 @@ type Delivery struct {
 	BaseModel
 
 	EventID  string         `gorm:"type:uuid;not null;index:idx_deliveries_event_id,priority:1"       json:"eventId"`
-	TargetID string         `gorm:"type:uuid;not null;index:idx_deliveries_status,priority:4"         json:"targetId"`
+	TargetID string         `gorm:"type:uuid;not null"                                                json:"targetId"`
 	Status   DeliveryStatus `gorm:"not null;default:'pending';index:idx_deliveries_status,priority:1" json:"status"`
 
 	// DeletedAt repeats the BaseModel field only to be the second column
@@ -49,13 +45,6 @@ type Delivery struct {
 	// gives.
 	DeletedAt gorm.DeletedAt `gorm:"index:idx_deliveries_event_id,priority:2;index:idx_deliveries_status,priority:2" json:"deletedAt,omitzero"`
 
-	// FinishedAt is when the delivery became delivered or failed, and
-	// nil while it is pending or retrying. It and then TargetID end the
-	// status index, so the webhook page counts each target's deliveries
-	// that finished in a recent window by reading just that window from
-	// the index.
-	FinishedAt *time.Time `gorm:"index:idx_deliveries_status,priority:3" json:"finishedAt,omitempty"`
-
 	// Relations
 	Event           Event            `json:"event,omitzero"`
 	Target          Target           `json:"target,omitzero"`

internal/database/model_totals.go

@@ -1,91 +0,0 @@
-package database
-
-import (
-	"fmt"
-
-	"gorm.io/gorm"
-)
-
-// The running totals in a webhook's event database keep the webhook
-// page's lifetime figures right after retention has removed the rows
-// they count, and let the page show them without counting every row.
-// Each total changes in the transaction that writes or deletes the
-// rows it counts.
-
-// EventTotals is the single row counting a webhook's events: every
-// event ever stored, and how many of them retention has deleted.
-type EventTotals struct {
-	ID int64 `gorm:"primaryKey"`
-
-	Events        int64 `gorm:"not null"`
-	EventsRemoved int64 `gorm:"not null"`
-}
-
-// TableName names the table AddEventTotals updates.
-func (EventTotals) TableName() string {
-	return "event_totals"
-}
-
-// TargetTotals is one row per target counting its deliveries: every
-// delivery ever created, how many became delivered and how many
-// failed, and how many deliveries and failed deliveries retention has
-// deleted. The webhook's delivery figures are these rows summed.
-type TargetTotals struct {
-	TargetID string `gorm:"type:uuid;primaryKey"`
-
-	Deliveries int64 `gorm:"not null"`
-	Delivered  int64 `gorm:"not null"`
-	Failed     int64 `gorm:"not null"`
-
-	DeliveriesRemoved int64 `gorm:"not null"`
-	FailedRemoved     int64 `gorm:"not null"`
-}
-
-// TableName names the table AddTargetTotals updates.
-func (TargetTotals) TableName() string {
-	return "target_totals"
-}
-
-// AddEventTotals adds each count in add to the webhook's event totals.
-// Call it on the transaction that writes or deletes the events it
-// counts.
-func AddEventTotals(tx *gorm.DB, add EventTotals) error {
-	err := tx.Exec(
-		`UPDATE event_totals SET
-			events = events + ?,
-			events_removed = events_removed + ?`,
-		add.Events, add.EventsRemoved,
-	).Error
-	if err != nil {
-		return fmt.Errorf("adding to event totals: %w", err)
-	}
-
-	return nil
-}
-
-// AddTargetTotals adds each count in add to the totals of the target
-// add.TargetID names, creating its row the first time. Call it on the
-// transaction that writes or deletes the deliveries it counts.
-func AddTargetTotals(tx *gorm.DB, add TargetTotals) error {
-	err := tx.Exec(
-		`INSERT INTO target_totals (target_id, deliveries, delivered,
-			failed, deliveries_removed, failed_removed)
-		VALUES (?, ?, ?, ?, ?, ?)
-		ON CONFLICT (target_id) DO UPDATE SET
-			deliveries = deliveries + excluded.deliveries,
-			delivered = delivered + excluded.delivered,
-			failed = failed + excluded.failed,
-			deliveries_removed =
-				deliveries_removed + excluded.deliveries_removed,
-			failed_removed = failed_removed + excluded.failed_removed`,
-		add.TargetID, add.Deliveries, add.Delivered,
-		add.Failed, add.DeliveriesRemoved, add.FailedRemoved,
-	).Error
-	if err != nil {
-		return fmt.Errorf(
-			"adding to totals of target %s: %w", add.TargetID, err,
-		)
-	}
-
-	return nil
-}

internal/database/model_user.go

@@ -1,58 +1,13 @@
 package database
 
-import (
-	"errors"
-	"fmt"
-
-	"gorm.io/gorm"
-)
-
-// MaxUsernameBytes is the longest username, in bytes, that a user may
-// have. The same number appears in the check constraint on
-// User.Username, because a struct tag cannot reference a constant.
-//
-// A login stores the username in the session cookie, and both
-// securecookie and browsers refuse a cookie value past about 4096
-// bytes. That value is the session base64-encoded twice, so it holds
-// 4096 × 3/4 × 3/4 = 2304 bytes of session, and the signature,
-// timestamp and the session's other values take about 270 of those: a
-// username longer than about 2030 bytes can never log in. The limit is
-// about half that, so the session can carry more values later without
-// locking out an account whose username is already at the limit.
-const MaxUsernameBytes = 1024
-
-// ErrUsernameTooLong is returned when a user is saved with a username
-// longer than MaxUsernameBytes.
-var ErrUsernameTooLong = errors.New("username is too long")
-
 // User represents a user of the webhooker service
-//
-//nolint:lll // a struct tag cannot wrap
 type User struct {
 	BaseModel
 
-	Username string `gorm:"uniqueIndex;not null;check:length(CAST(username AS BLOB)) <= 1024" json:"username"`
+	Username string `gorm:"uniqueIndex;not null" json:"username"`
-	Password string `gorm:"not null"                                                          json:"-"` // Argon2 hashed
+	Password string `gorm:"not null"             json:"-"` // Argon2 hashed
 
 	// Relations
 	Webhooks []Webhook `json:"webhooks,omitempty"`
 	APIKeys  []APIKey  `json:"apiKeys,omitempty"`
 }
-
-// BeforeSave rejects a username longer than MaxUsernameBytes when a whole
-// User is created or saved, so those calls get ErrUsernameTooLong rather
-// than the database's constraint error. A column update such as
-// Update("username", ...) is caught only by the check constraint, as is
-// any path that writes the table without this model.
-func (u *User) BeforeSave(_ *gorm.DB) error {
-	if len(u.Username) > MaxUsernameBytes {
-		return fmt.Errorf(
-			"%w: %d bytes, limit is %d",
-			ErrUsernameTooLong,
-			len(u.Username),
-			MaxUsernameBytes,
-		)
-	}
-
-	return nil
-}

internal/database/model_user_test.go

@@ -1,65 +0,0 @@
-package database_test
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/webhooker/internal/database"
-)
-
-// usernameAtLimit is exactly MaxUsernameBytes long, built from a
-// two-byte character. A check that counted characters rather than bytes
-// would see half the length and let the one-byte-longer name through.
-func usernameAtLimit() string {
-	return strings.Repeat("é", database.MaxUsernameBytes/2)
-}
-
-func TestUserCreate_RejectsOverlongUsername(t *testing.T) {
-	t.Parallel()
-
-	db := startedTestDB(t)
-
-	err := db.Create(&database.User{
-		Username: usernameAtLimit() + "x",
-		Password: "hash",
-	}).Error
-
-	require.ErrorIs(t, err, database.ErrUsernameTooLong)
-}
-
-func TestUserCreate_AcceptsUsernameAtLimit(t *testing.T) {
-	t.Parallel()
-
-	db := startedTestDB(t)
-
-	require.NoError(t, db.Create(&database.User{
-		Username: usernameAtLimit(),
-		Password: "hash",
-	}).Error)
-}
-
-// TestUsersTable_EnforcesUsernameLimitWithoutTheModel inserts with raw
-// SQL, as a path that bypassed User.BeforeSave would, so only the
-// table's check constraint stands between it and an over-long
-// username. Accepting the name at the limit and refusing the next byte
-// also pins the constraint's number to MaxUsernameBytes.
-func TestUsersTable_EnforcesUsernameLimitWithoutTheModel(t *testing.T) {
-	t.Parallel()
-
-	db := startedTestDB(t)
-
-	insert := "INSERT INTO users (id, username, password) VALUES (?, ?, ?)"
-
-	require.NoError(t, db.Exec(
-		insert, uuid.New().String(), usernameAtLimit(), "hash",
-	).Error)
-
-	err := db.Exec(
-		insert, uuid.New().String(), usernameAtLimit()+"x", "hash",
-	).Error
-	require.Error(t, err)
-	assert.Contains(t, err.Error(), "CHECK constraint failed")
-}

internal/database/models.go

@@ -2,8 +2,7 @@ package database
 
 // Migrate runs database migrations for the main application database.
 // Only configuration-tier models are stored in the main database.
-// Event-tier models (Event, Delivery, DeliveryResult, EventTotals,
+// Event-tier models (Event, Delivery, DeliveryResult) live in
-// TargetTotals) live in
 // per-webhook dedicated databases managed by WebhookDBManager.
 func (d *Database) Migrate() error {
 	return d.db.AutoMigrate(

internal/database/retention.go

@@ -18,13 +18,6 @@ import (
 // computation.
 const hoursPerDay = 24
 
-// reapBatchSize is how many expired events one retention transaction
-// deletes. A transaction holds the event database's write lock, which
-// the receiver and the delivery workers wait for, so a large prune is
-// split into transactions each short enough to finish well inside the
-// busy timeout.
-const reapBatchSize = 1000
-
 // RetentionReaperParams holds the fx dependencies for the
 // RetentionReaper.
 type RetentionReaperParams struct {
@@ -272,97 +265,57 @@ func retentionCutoff(
 	), true
 }
 
-// reapExpired hard-deletes the events older than cutoff, with their
+// reapExpired hard-deletes, in foreign-key-safe order, the delivery
-// deliveries and delivery results, reapBatchSize events per
+// results, deliveries, and events associated with events older than
-// transaction until none is left. It returns the number of events
+// cutoff. Deletes are unscoped so rows are physically removed rather
+// than soft-deleted, reclaiming disk. It returns the number of events
 // deleted.
 func reapExpired(db *gorm.DB, cutoff time.Time) (int64, error) {
-	var total int64
+	// Fresh subqueries are built per statement to avoid reusing a
-
+	// mutated builder across executions.
-	for {
+	expiredEventIDs := func() *gorm.DB {
-		var eventIDs []string
+		return db.Model(&Event{}).
-
-		err := db.Transaction(func(tx *gorm.DB) error {
-			err := tx.Unscoped().Model(&Event{}).
-				Where("created_at < ?", cutoff).
-				Limit(reapBatchSize).
-				Pluck("id", &eventIDs).Error
-			if err != nil {
-				return fmt.Errorf("selecting expired events: %w", err)
-			}
-
-			if len(eventIDs) == 0 {
-				return nil
-			}
-
-			return deleteEvents(tx, eventIDs)
-		})
-		if err != nil {
-			return total, err
-		}
-
-		total += int64(len(eventIDs))
-
-		if len(eventIDs) < reapBatchSize {
-			return total, nil
-		}
-	}
-}
-
-// deleteEvents hard-deletes the given events and, in foreign-key-safe
-// order before them, their delivery results and deliveries, then adds
-// what it deleted to the running totals. It runs on reapExpired's
-// transaction, so the totals change exactly when the rows do. Deletes
-// are unscoped so rows are physically removed rather than
-// soft-deleted, reclaiming disk.
-func deleteEvents(tx *gorm.DB, eventIDs []string) error {
-	// 1. The delivery results of the events' deliveries.
-	err := tx.Unscoped().
-		Where("delivery_id IN (?)", tx.Unscoped().Model(&Delivery{}).
 			Select("id").
-			Where("event_id IN ?", eventIDs)).
+			Where("created_at < ?", cutoff)
-		Delete(&DeliveryResult{}).Error
+	}
-	if err != nil {
+	expiredDeliveryIDs := func() *gorm.DB {
-		return fmt.Errorf("deleting expired delivery results: %w", err)
+		return db.Model(&Delivery{}).
+			Select("id").
+			Where("event_id IN (?)", expiredEventIDs())
 	}
 
-	// 2. The events' deliveries, after counting them, and the failed
+	// 1. Delivery results whose delivery belongs to an expired event.
-	// ones among them, per target. The status is tested in the select
+	res := db.Unscoped().
-	// list rather than the WHERE clause: there, SQLite would read every
+		Where("delivery_id IN (?)", expiredDeliveryIDs()).
-	// failed delivery the webhook has through the status index,
+		Delete(&DeliveryResult{})
-	// instead of only these through the event_id index.
+	if res.Error != nil {
-	var removed []TargetTotals
+		return 0, fmt.Errorf(
-
+			"deleting expired delivery results: %w",
-	err = tx.Unscoped().Model(&Delivery{}).
+			res.Error,
-		Select("target_id, count(*) AS deliveries_removed, "+
+		)
-			"count(CASE WHEN status = ? THEN 1 END) AS failed_removed",
-			DeliveryStatusFailed).
-		Where("event_id IN ?", eventIDs).
-		Group("target_id").
-		Find(&removed).Error
-	if err != nil {
-		return fmt.Errorf("counting expired deliveries: %w", err)
 	}
 
-	err = tx.Unscoped().
+	// 2. Deliveries belonging to an expired event.
-		Where("event_id IN ?", eventIDs).
+	del := db.Unscoped().
-		Delete(&Delivery{}).Error
+		Where("event_id IN (?)", expiredEventIDs()).
-	if err != nil {
+		Delete(&Delivery{})
-		return fmt.Errorf("deleting expired deliveries: %w", err)
+	if del.Error != nil {
+		return 0, fmt.Errorf(
+			"deleting expired deliveries: %w",
+			del.Error,
+		)
 	}
 
-	// 3. The events themselves.
+	// 3. The expired events themselves.
-	ev := tx.Unscoped().Where("id IN ?", eventIDs).Delete(&Event{})
+	ev := db.Unscoped().
+		Where("created_at < ?", cutoff).
+		Delete(&Event{})
 	if ev.Error != nil {
-		return fmt.Errorf("deleting expired events: %w", ev.Error)
+		return 0, fmt.Errorf(
+			"deleting expired events: %w",
+			ev.Error,
+		)
 	}
 
-	for i := range removed {
+	return ev.RowsAffected, nil
-		err = AddTargetTotals(tx, removed[i])
-		if err != nil {
-			return err
-		}
-	}
-
-	return AddEventTotals(tx, EventTotals{EventsRemoved: ev.RowsAffected})
 }

internal/database/totals_test.go

@@ -1,228 +0,0 @@
-package database_test
-
-import (
-	"context"
-	"net/http"
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gorm.io/gorm"
-	"sneak.berlin/go/webhooker/internal/database"
-)
-
-// readEventTotals reads a webhook database's row of event totals,
-// asserting that it has exactly one.
-func readEventTotals(t *testing.T, db *gorm.DB) database.EventTotals {
-	t.Helper()
-
-	var rows []database.EventTotals
-
-	require.NoError(t, db.Find(&rows).Error)
-	require.Len(t, rows, 1)
-
-	return rows[0]
-}
-
-// readTargetTotals reads a webhook database's target totals, keyed by
-// target.
-func readTargetTotals(
-	t *testing.T, db *gorm.DB,
-) map[string]database.TargetTotals {
-	t.Helper()
-
-	var rows []database.TargetTotals
-
-	require.NoError(t, db.Find(&rows).Error)
-
-	byTarget := make(map[string]database.TargetTotals, len(rows))
-	for _, row := range rows {
-		byTarget[row.TargetID] = row
-	}
-
-	return byTarget
-}
-
-// TestWebhookDBManager_TotalsSurviveReopen verifies that a new event
-// database starts with one row of zero event totals and no target
-// totals, that adding to a target twice adds to the one row, and that
-// opening the database again keeps everything added.
-func TestWebhookDBManager_TotalsSurviveReopen(t *testing.T) {
-	t.Parallel()
-
-	mgr, lc := setupTestWebhookDBManager(t)
-	ctx := context.Background()
-	require.NoError(t, lc.Start(ctx))
-
-	defer func() { require.NoError(t, lc.Stop(ctx)) }()
-
-	webhookID := uuid.New().String()
-
-	db, err := mgr.GetDB(webhookID)
-	require.NoError(t, err)
-
-	fresh := readEventTotals(t, db)
-	assert.Equal(t, database.EventTotals{ID: fresh.ID}, fresh)
-	assert.Empty(t, readTargetTotals(t, db))
-
-	first, second := uuid.New().String(), uuid.New().String()
-
-	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
-		Events: 2,
-	}))
-	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
-		TargetID: first, Deliveries: 2, Delivered: 1,
-	}))
-	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
-		TargetID: first, Failed: 1,
-	}))
-	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
-		TargetID: second, Deliveries: 1,
-	}))
-
-	// Drop the cached connection so the next open reopens the file,
-	// as a restart would.
-	require.NoError(t, mgr.CloseAll())
-
-	db, err = mgr.GetDB(webhookID)
-	require.NoError(t, err)
-
-	assert.Equal(t, database.EventTotals{ID: fresh.ID, Events: 2},
-		readEventTotals(t, db))
-	assert.Equal(t, map[string]database.TargetTotals{
-		first: {
-			TargetID: first, Deliveries: 2, Delivered: 1, Failed: 1,
-		},
-		second: {TargetID: second, Deliveries: 1},
-	}, readTargetTotals(t, db))
-}
-
-// seedExpiredEvents stores count events created at the given time,
-// each with a delivered delivery to one target and a failed delivery
-// to the other, and one attempt for each delivery.
-func seedExpiredEvents(
-	t *testing.T,
-	db *gorm.DB,
-	webhookID string,
-	count int,
-	createdAt time.Time,
-	delivered, failed string,
-) {
-	t.Helper()
-
-	events := make([]database.Event, count)
-	deliveries := make([]database.Delivery, 0, 2*count)
-
-	for i := range events {
-		events[i] = database.Event{
-			WebhookID:    webhookID,
-			EntrypointID: uuid.New().String(),
-			Method:       http.MethodPost,
-		}
-		events[i].ID = uuid.New().String()
-		events[i].CreatedAt = createdAt
-
-		deliveries = append(deliveries,
-			database.Delivery{
-				EventID:  events[i].ID,
-				TargetID: delivered,
-				Status:   database.DeliveryStatusDelivered,
-			},
-			database.Delivery{
-				EventID:  events[i].ID,
-				TargetID: failed,
-				Status:   database.DeliveryStatusFailed,
-			},
-		)
-	}
-
-	require.NoError(t, db.CreateInBatches(events, 500).Error)
-	require.NoError(t, db.CreateInBatches(deliveries, 500).Error)
-
-	results := make([]database.DeliveryResult, len(deliveries))
-	for i := range deliveries {
-		results[i] = database.DeliveryResult{
-			DeliveryID: deliveries[i].ID, AttemptNum: 1,
-		}
-	}
-
-	require.NoError(t, db.CreateInBatches(results, 500).Error)
-}
-
-// TestRetentionReaper_PrunesMoreThanOneBatch verifies that a prune
-// larger than one transaction's batch removes every expired event with
-// its deliveries and delivery results, keeps the recent event, and
-// adds what it removed to the event and target totals, so the totals
-// within retention match the rows still stored.
-func TestRetentionReaper_PrunesMoreThanOneBatch(t *testing.T) {
-	t.Parallel()
-
-	env := setupRetentionTest(t)
-
-	webhookID := createWebhook(t, env.mainDB.DB(), 30)
-
-	db, err := env.mgr.GetDB(webhookID)
-	require.NoError(t, err)
-
-	expired := database.ExportReapBatchSize + 1
-	delivered, failed := uuid.New().String(), uuid.New().String()
-	seedExpiredEvents(t, db, webhookID, expired,
-		time.Now().Add(-40*24*time.Hour), delivered, failed)
-
-	// One recent event, delivered to the first target.
-	recent := seedEventChain(t, db, webhookID, time.Now())
-	require.NoError(t, db.Model(&database.Delivery{}).
-		Where("id = ?", recent.deliveryID).
-		Update("target_id", delivered).Error)
-
-	// The totals storing those rows would have left.
-	n := int64(expired)
-	require.NoError(t, database.AddEventTotals(db, database.EventTotals{
-		Events: n + 1,
-	}))
-	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
-		TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
-	}))
-	require.NoError(t, database.AddTargetTotals(db, database.TargetTotals{
-		TargetID: failed, Deliveries: n, Failed: n,
-	}))
-
-	env.reaper.ExportSweep(context.Background())
-
-	// Only the recent event's rows are left.
-	for _, model := range []any{
-		&database.Event{}, &database.Delivery{}, &database.DeliveryResult{},
-	} {
-		var count int64
-
-		require.NoError(t, db.Model(model).Count(&count).Error)
-		assert.Equal(t, int64(1), count, "%T rows left", model)
-	}
-
-	assertChainPresent(t, db, recent)
-
-	eventTotals := readEventTotals(t, db)
-	assert.Equal(t, database.EventTotals{
-		ID: eventTotals.ID, Events: n + 1, EventsRemoved: n,
-	}, eventTotals)
-
-	targetTotals := readTargetTotals(t, db)
-	assert.Equal(t, map[string]database.TargetTotals{
-		delivered: {
-			TargetID: delivered, Deliveries: n + 1, Delivered: n + 1,
-			DeliveriesRemoved: n,
-		},
-		failed: {
-			TargetID: failed, Deliveries: n, Failed: n,
-			DeliveriesRemoved: n, FailedRemoved: n,
-		},
-	}, targetTotals)
-
-	// A sweep with nothing left to remove changes nothing.
-	env.reaper.ExportSweep(context.Background())
-
-	assert.Equal(t, eventTotals, readEventTotals(t, db))
-	assert.Equal(t, targetTotals, readTargetTotals(t, db))
-}

internal/database/webhook_db_manager.go

@@ -35,8 +35,7 @@ var errInvalidCachedDBType = errors.New(
 
 // WebhookDBManager manages per-webhook SQLite database files
 // for event storage. Each webhook gets its own dedicated
-// database containing Events, Deliveries, DeliveryResults and the
+// database containing Events, Deliveries, and DeliveryResults.
-// running totals of them (EventTotals, TargetTotals).
 // Database connections are opened lazily and cached.
 type WebhookDBManager struct {
 	dataDir string
@@ -296,7 +295,6 @@ func (m *WebhookDBManager) openDB(
 	// Run migrations for event-tier models only
 	err = db.AutoMigrate(
 		&Event{}, &Delivery{}, &DeliveryResult{},
-		&EventTotals{}, &TargetTotals{},
 	)
 	if err != nil {
 		_ = sqlDB.Close()
@@ -307,18 +305,6 @@ func (m *WebhookDBManager) openDB(
 		)
 	}
 
-	// A new database gets its row of event totals, all zero. Target
-	// totals rows are created by the first delivery to each target.
-	err = db.FirstOrCreate(&EventTotals{}).Error
-	if err != nil {
-		_ = sqlDB.Close()
-
-		return nil, fmt.Errorf(
-			"creating event totals for webhook database %s: %w",
-			webhookID, err,
-		)
-	}
-
 	m.log.Info(
 		"opened per-webhook database",
 		"webhook_id", webhookID,

internal/delivery/delivery_totals_test.go

@@ -1,116 +0,0 @@
-package delivery_test
-
-import (
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"gorm.io/gorm"
-	"sneak.berlin/go/webhooker/internal/database"
-)
-
-// targetTotals reads one target's totals from a webhook database, all
-// zero when it has no row.
-func targetTotals(
-	t *testing.T, db *gorm.DB, targetID string,
-) database.TargetTotals {
-	t.Helper()
-
-	var rows []database.TargetTotals
-
-	require.NoError(t, db.Where("target_id = ?", targetID).
-		Find(&rows).Error)
-
-	if len(rows) == 0 {
-		return database.TargetTotals{TargetID: targetID}
-	}
-
-	return rows[0]
-}
-
-// TestUpdateDeliveryStatus_FinishTimeAndTargetTotals pins what a status
-// write records for the webhook page's statistics: the time a delivery
-// finished, set only when it becomes delivered or failed, and one more
-// on its target's delivered or failed total.
-func TestUpdateDeliveryStatus_FinishTimeAndTargetTotals(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		status    database.DeliveryStatus
-		finished  bool
-		delivered int64
-		failed    int64
-	}{
-		{database.DeliveryStatusRetrying, false, 0, 0},
-		{database.DeliveryStatusDelivered, true, 1, 0},
-		{database.DeliveryStatusFailed, true, 0, 1},
-	}
-
-	for _, tt := range tests {
-		t.Run(string(tt.status), func(t *testing.T) {
-			t.Parallel()
-
-			db := testWebhookDB(t)
-			e := testEngine(t, 1)
-			event := seedEvent(t, db, `{}`)
-			targetID := uuid.New().String()
-			d := seedDelivery(
-				t, db, event.ID, targetID,
-				database.DeliveryStatusPending,
-			)
-
-			before := time.Now()
-
-			require.NoError(t, e.ExportUpdateDeliveryStatus(
-				db, &d, tt.status,
-			))
-
-			var stored database.Delivery
-
-			require.NoError(t, db.First(&stored, "id = ?", d.ID).Error)
-			assert.Equal(t, tt.status, stored.Status)
-
-			if tt.finished {
-				require.NotNil(t, stored.FinishedAt)
-				assert.False(t, stored.FinishedAt.Before(before))
-			} else {
-				assert.Nil(t, stored.FinishedAt)
-			}
-
-			assert.Equal(t, database.TargetTotals{
-				TargetID:  targetID,
-				Delivered: tt.delivered,
-				Failed:    tt.failed,
-			}, targetTotals(t, db, targetID))
-		})
-	}
-}
-
-// TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted covers a
-// delivery retention deleted while the engine still held it. Failing
-// it afterwards writes no row, so it adds no failure either: retention
-// has already counted what it removed.
-func TestUpdateDeliveryStatus_DeletedDeliveryIsNotCounted(t *testing.T) {
-	t.Parallel()
-
-	db := testWebhookDB(t)
-	e := testEngine(t, 1)
-	event := seedEvent(t, db, `{}`)
-	targetID := uuid.New().String()
-	d := seedDelivery(
-		t, db, event.ID, targetID,
-		database.DeliveryStatusRetrying,
-	)
-
-	require.NoError(t, db.Unscoped().
-		Delete(&database.Delivery{}, "id = ?", d.ID).Error)
-
-	require.NoError(t, e.ExportUpdateDeliveryStatus(
-		db, &d, database.DeliveryStatusFailed,
-	))
-
-	assert.Equal(t, database.TargetTotals{TargetID: targetID},
-		targetTotals(t, db, targetID))
-}

internal/delivery/engine.go

@@ -1554,9 +1554,8 @@ func (e *Engine) updateDeliveryStatus(
 	targetType database.TargetType,
 	status database.DeliveryStatus,
 ) error {
-	err := webhookDB.Transaction(func(tx *gorm.DB) error {
+	err := webhookDB.Model(d).
-		return writeDeliveryStatus(tx, d, status)
+		Update("status", status).Error
-	})
 	if err != nil {
 		return fmt.Errorf(
 			"updating delivery %s to status %s: %w",
@@ -1575,36 +1574,6 @@ func (e *Engine) updateDeliveryStatus(
 	return nil
 }
 
-// writeDeliveryStatus writes a delivery's new status. A delivery that
-// becomes delivered or failed also gets the time it finished, and is
-// added to its target's delivered or failed total. It is counted only
-// if the row was still there to update: retention may have deleted it
-// while the engine was working on it.
-func writeDeliveryStatus(
-	tx *gorm.DB,
-	d *database.Delivery,
-	status database.DeliveryStatus,
-) error {
-	if !status.Terminal() {
-		return tx.Model(d).Update("status", status).Error
-	}
-
-	res := tx.Model(d).Updates(map[string]any{
-		"status":      status,
-		"finished_at": time.Now(),
-	})
-	if res.Error != nil || res.RowsAffected == 0 {
-		return res.Error
-	}
-
-	add := database.TargetTotals{TargetID: d.TargetID, Delivered: 1}
-	if status == database.DeliveryStatusFailed {
-		add = database.TargetTotals{TargetID: d.TargetID, Failed: 1}
-	}
-
-	return database.AddTargetTotals(tx, add)
-}
-
 // settleStatus moves a delivery to its outcome status and reports a
 // failed write through bookkeepingFailed, which leaves the row
 // recoverable. It exists so the target call sites read as one

internal/delivery/engine_test.go

@@ -57,10 +57,7 @@ func testWebhookDB(t *testing.T) *gorm.DB {
 		&database.Event{},
 		&database.Delivery{},
 		&database.DeliveryResult{},
-		&database.EventTotals{},
-		&database.TargetTotals{},
 	))
-	require.NoError(t, db.Create(&database.EventTotals{}).Error)
 
 	return db
 }

internal/delivery/export_test.go

@@ -150,16 +150,6 @@ func (e *Engine) ExportDeliverSlack(
 	)
 }
 
-// ExportUpdateDeliveryStatus exposes updateDeliveryStatus. It passes no
-// target type, so no metric moves.
-func (e *Engine) ExportUpdateDeliveryStatus(
-	webhookDB *gorm.DB,
-	d *database.Delivery,
-	status database.DeliveryStatus,
-) error {
-	return e.updateDeliveryStatus(webhookDB, d, "", status)
-}
-
 // ExportProcessNewTask exposes processNewTask.
 func (e *Engine) ExportProcessNewTask(
 	ctx context.Context, task *Task,

internal/handlers/auth_test.go

@@ -453,33 +453,3 @@ func TestLogin_SuccessCreatesSession(t *testing.T) {
 		"the issued cookie must carry an authenticated session",
 	)
 }
-
-// TestLogin_UsernameAtLimitCanLogIn shows that a username of exactly
-// database.MaxUsernameBytes still fits in the session cookie. Past
-// what the cookie can carry, a correct login answers 500.
-func TestLogin_UsernameAtLimitCanLogIn(t *testing.T) {
-	t.Parallel()
-
-	var (
-		h  *handlers.Handlers
-		db *database.Database
-	)
-
-	app := newTestApp(t, &h, &db)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	username := strings.Repeat("a", database.MaxUsernameBytes)
-
-	hash, err := database.HashPassword(operatorPassword)
-	require.NoError(t, err)
-	require.NoError(t, db.DB().Create(&database.User{
-		Username: username,
-		Password: hash,
-	}).Error)
-
-	w := submitLogin(h, sharedProxyPeer, username, operatorPassword)
-
-	assert.Equal(t, http.StatusSeeOther, w.Code)
-}

internal/handlers/delivery_replay.go

@@ -299,9 +299,8 @@ func countInFlightDeliveries(
 	return count, err
 }
 
-// createReplayDelivery writes the new pending delivery row, adds it to
+// createReplayDelivery writes the new pending delivery row and returns
-// its target's totals in the same transaction, and returns the task
+// the task that carries it to the delivery engine.
-// that carries it to the delivery engine.
 //
 // The row is written with associations omitted, and neither Event nor
 // Target is populated on it: GORM's SaveBeforeAssociations would
@@ -320,16 +319,7 @@ func createReplayDelivery(
 		Status:   database.DeliveryStatusPending,
 	}
 
-	err := webhookDB.Transaction(func(tx *gorm.DB) error {
+	err := webhookDB.Omit(clause.Associations).Create(dlv).Error
-		err := tx.Omit(clause.Associations).Create(dlv).Error
-		if err != nil {
-			return err
-		}
-
-		return database.AddTargetTotals(tx, database.TargetTotals{
-			TargetID: dlv.TargetID, Deliveries: 1,
-		})
-	})
 	if err != nil {
 		return delivery.Task{}, err
 	}

internal/handlers/export_test.go

@@ -4,9 +4,7 @@ import (
 	"html/template"
 	"log/slog"
 	"net/http"
-	"time"
 
-	"gorm.io/gorm"
 	"sneak.berlin/go/webhooker/internal/database"
 )
 
@@ -71,29 +69,6 @@ func (s *Handlers) LoadEventLogViewsForTest(
 	return views
 }
 
-// WebhookStatsForTest returns the figures the statistics pane on a
-// webhook's page shows, from the webhook's entrypoints and targets
-// loaded as that page loads them.
-func (s *Handlers) WebhookStatsForTest(webhookID string) *WebhookStats {
-	var entrypoints []database.Entrypoint
-
-	s.db.DB().Where("webhook_id = ?", webhookID).Find(&entrypoints)
-
-	var targets []database.Target
-
-	s.db.DB().Where("webhook_id = ?", webhookID).Find(&targets)
-
-	return s.loadWebhookStats(webhookID, entrypoints, targets)
-}
-
-// FinishedByTargetForTest exposes finishedByTarget for use in the
-// handlers_test package.
-func FinishedByTargetForTest(
-	webhookDB *gorm.DB, since time.Time,
-) ([]TargetFinished, error) {
-	return finishedByTarget(webhookDB, since)
-}
-
 // AddTemplateForTest registers a template under a page name so that
 // the handlers_test package can drive the render path with a
 // template of its own.

internal/handlers/handlers.go

@@ -91,22 +91,18 @@ type Handlers struct {
 
 // parsePageTemplate parses a page-specific template set from the
 // embedded FS. Each page template is combined with the shared
-// base, htmlheader, and navbar templates, and with any further files
+// base, htmlheader, and navbar templates. The page file must be
-// the page includes. The page file must be listed first so that its
+// listed first so that its root action ({{template "base" .}})
-// root action ({{template "base" .}}) becomes the template set's entry
+// becomes the template set's entry point.
-// point.
+func parsePageTemplate(pageFile string) *template.Template {
-func parsePageTemplate(
-	pageFile string, included ...string,
-) *template.Template {
-	files := append([]string{
-		pageFile,
-		"base.html",
-		"htmlheader.html",
-		"navbar.html",
-	}, included...)
-
 	return template.Must(
-		template.ParseFS(templates.Templates, files...),
+		template.ParseFS(
+			templates.Templates,
+			pageFile,
+			"base.html",
+			"htmlheader.html",
+			"navbar.html",
+		),
 	)
 }
 
@@ -135,7 +131,7 @@ func New(
 		"profile.html":       parsePageTemplate("profile.html"),
 		"sources_list.html":  parsePageTemplate("sources_list.html"),
 		"sources_new.html":   parsePageTemplate("sources_new.html"),
-		"source_detail.html": parsePageTemplate("source_detail.html", "webhook_stats.html"),
+		"source_detail.html": parsePageTemplate("source_detail.html"),
 		"source_edit.html":   parsePageTemplate("source_edit.html"),
 		"source_logs.html":   parsePageTemplate("source_logs.html"),
 		"target_edit.html":   parsePageTemplate("target_edit.html"),

internal/handlers/logbound_test.go

@@ -339,9 +339,11 @@ const storedUserPassword = "correct-horse-battery-staple"
 // storedFillBytes is the raw length of the client-chosen value in
 // those accounts' usernames. It is well past the 512-byte field
 // budget, so the line is still truncated, but short enough that the
-// whole username, markers and fill name included, stays within
+// session cookie a successful login writes stays inside
-// database.MaxUsernameBytes.
+// securecookie's 4 KB limit: the cookie is written BEFORE the
-const storedFillBytes = 960
+// "user logged in" line, so an 8 KB username answers 500 and never
+// reaches it.
+const storedFillBytes = 1024
 
 // storedFill builds a username fill of storedFillBytes raw bytes out
 // of repetitions of ch, with both markers at its far end.

internal/handlers/profile_test.go

@@ -88,8 +88,6 @@ func TestHandleProfile_OwnProfile_OK(t *testing.T) {
 	h.HandleProfile().ServeHTTP(w, req)
 
 	assert.Equal(t, http.StatusOK, w.Code)
-	assert.Contains(t, w.Body.String(), "Account Information")
-	assert.NotContains(t, w.Body.String(), "Account Type")
 }
 
 func TestHandleProfile_OtherProfile_Forbidden(t *testing.T) {

internal/handlers/source_management.go

@@ -450,7 +450,6 @@ func (h *Handlers) renderSourceDetail(
 		"Targets":     delivery.NewTargetViews(targets),
 		"Events":      events,
 		"BaseURL":     baseURL,
-		"Stats":       h.loadWebhookStats(webhook.ID, entrypoints, targets),
 	}
 
 	h.renderTemplate(w, r, "source_detail.html", data)

internal/handlers/webhook.go

@@ -252,12 +252,11 @@ func requestEventSource(
 	}
 }
 
-// createAndFanOut writes the event and one pending delivery per target,
+// createAndFanOut writes the event and one pending delivery per target
-// and adds them to the webhook's running totals, in a single
+// in a single transaction, then hands the tasks to the delivery
-// transaction, then hands the tasks to the delivery engine. It is the
+// engine. It is the only path by which an event and its deliveries are
-// only path by which an event and its deliveries are created, so a
+// created, so a resubmitted event is retried, SSRF-guarded and
-// resubmitted event is retried, SSRF-guarded and circuit-broken
+// circuit-broken exactly as a received one is.
-// exactly as a received one is.
 //
 // The tasks are returned as well as queued, so a caller can report how
 // many targets the event went to.
@@ -297,13 +296,6 @@ func (h *Handlers) createAndFanOut(
 		return nil, nil, err
 	}
 
-	err = database.AddEventTotals(tx, database.EventTotals{Events: 1})
-	if err != nil {
-		tx.Rollback()
-
-		return nil, nil, err
-	}
-
 	err = tx.Commit().Error
 	if err != nil {
 		return nil, nil, fmt.Errorf(
@@ -362,9 +354,8 @@ func (h *Handlers) finishWebhookResponse(
 }
 
 // buildDeliveryTasks creates one pending delivery per target in the
-// transaction, adds each to its target's totals, and returns the tasks
+// transaction and returns the tasks for the delivery engine. The
-// for the delivery engine. The caller owns the transaction and rolls
+// caller owns the transaction and rolls it back on error.
-// it back on error.
 func buildDeliveryTasks(
 	tx *gorm.DB,
 	event *database.Event,
@@ -388,13 +379,6 @@ func buildDeliveryTasks(
 			)
 		}
 
-		err = database.AddTargetTotals(tx, database.TargetTotals{
-			TargetID: targets[i].ID, Deliveries: 1,
-		})
-		if err != nil {
-			return nil, err
-		}
-
 		tasks = append(tasks, delivery.Task{
 			DeliveryID:   dlv.ID,
 			EventID:      event.ID,

internal/handlers/webhook_stats.go

@@ -1,271 +0,0 @@
-package handlers
-
-import (
-	"fmt"
-	"time"
-
-	"gorm.io/gorm"
-	"sneak.berlin/go/webhooker/internal/database"
-)
-
-// The spans of the two recent windows the statistics pane reports on:
-// the last 10 minutes and the last 24 hours.
-const (
-	shortWindow = 10 * time.Minute
-	longWindow  = 24 * time.Hour
-)
-
-// percent turns a fraction into a percentage.
-const percent = 100
-
-// WebhookStats holds the figures in the statistics pane at the top of
-// the webhook page.
-type WebhookStats struct {
-	Entrypoints       int
-	ActiveEntrypoints int
-	Targets           int
-	ActiveTargets     int
-
-	// Lifetime counts every event, delivery and failure the webhook
-	// has had, and WithinRetention those still stored.
-	Lifetime        Counts
-	WithinRetention Counts
-
-	// InProgress counts the deliveries still pending or retrying.
-	InProgress int64
-
-	// LastEventAt is when the newest stored event arrived, or nil when
-	// none is stored.
-	LastEventAt *time.Time
-
-	Last10Minutes RecentWindow
-	Last24Hours   RecentWindow
-}
-
-// Counts holds a number of events, of deliveries and of failed
-// deliveries.
-type Counts struct {
-	Events     int64
-	Deliveries int64
-	Failures   int64
-}
-
-// RecentWindow holds what happened in one recent window: the events
-// received in it, and the deliveries that became delivered or failed in
-// it.
-type RecentWindow struct {
-	Events    int64
-	Delivered int64
-	Failed    int64
-}
-
-// TargetFinished is how many of one target's deliveries became
-// delivered, and how many failed, in a recent window.
-type TargetFinished struct {
-	TargetID  string
-	Delivered int64
-	Failed    int64
-}
-
-// FailurePercent is the share of the deliveries finished in the window
-// that failed, or a dash when none finished. Deliveries still pending
-// or retrying are not counted either way.
-func (w RecentWindow) FailurePercent() string {
-	finished := w.Delivered + w.Failed
-	if finished == 0 {
-		return "—"
-	}
-
-	return fmt.Sprintf(
-		"%.1f%%", percent*float64(w.Failed)/float64(finished),
-	)
-}
-
-// loadWebhookStats gathers the figures for the statistics pane from the
-// webhook's entrypoints and targets, as the page has already loaded
-// them, and from its event database. It returns nil, and logs why, when
-// the event database cannot be read.
-func (h *Handlers) loadWebhookStats(
-	webhookID string,
-	entrypoints []database.Entrypoint,
-	targets []database.Target,
-) *WebhookStats {
-	stats := &WebhookStats{
-		Entrypoints: len(entrypoints),
-		Targets:     len(targets),
-	}
-
-	for i := range entrypoints {
-		if entrypoints[i].Active {
-			stats.ActiveEntrypoints++
-		}
-	}
-
-	for i := range targets {
-		if targets[i].Active {
-			stats.ActiveTargets++
-		}
-	}
-
-	// Opening an event database that does not exist would create it,
-	// and it would hold nothing to count.
-	if !h.dbMgr.DBExists(webhookID) {
-		return stats
-	}
-
-	webhookDB, err := h.dbMgr.GetDB(webhookID)
-	if err == nil {
-		err = readEventStats(webhookDB, time.Now(), stats)
-	}
-
-	if err != nil {
-		h.log.Error(
-			"failed to read webhook statistics",
-			"webhook_id", webhookID,
-			"error", err,
-		)
-
-		return nil
-	}
-
-	return stats
-}
-
-// readEventStats fills in the figures that come from the webhook's
-// event database. None of them reads every stored row: the totals are
-// one row for the events and one per target for the deliveries, and
-// every other figure is read from an index, over only the rows it
-// counts.
-func readEventStats(
-	db *gorm.DB, now time.Time, stats *WebhookStats,
-) error {
-	err := readTotals(db, stats)
-	if err != nil {
-		return err
-	}
-
-	err = db.Model(&database.Delivery{}).
-		Where("status IN ?", []database.DeliveryStatus{
-			database.DeliveryStatusPending,
-			database.DeliveryStatusRetrying,
-		}).
-		Count(&stats.InProgress).Error
-	if err != nil {
-		return fmt.Errorf("counting deliveries in progress: %w", err)
-	}
-
-	var newest []time.Time
-
-	err = db.Model(&database.Event{}).
-		Order("created_at DESC").
-		Limit(1).
-		Pluck("created_at", &newest).Error
-	if err != nil {
-		return fmt.Errorf("reading newest event time: %w", err)
-	}
-
-	if len(newest) > 0 {
-		stats.LastEventAt = &newest[0]
-	}
-
-	stats.Last10Minutes, err = readRecentWindow(
-		db, now.Add(-shortWindow),
-	)
-	if err != nil {
-		return err
-	}
-
-	stats.Last24Hours, err = readRecentWindow(
-		db, now.Add(-longWindow),
-	)
-
-	return err
-}
-
-// readTotals fills in the lifetime and within-retention figures from
-// the running totals: the events' row, and the targets' rows summed.
-func readTotals(db *gorm.DB, stats *WebhookStats) error {
-	var events database.EventTotals
-
-	err := db.Take(&events).Error
-	if err != nil {
-		return fmt.Errorf("reading event totals: %w", err)
-	}
-
-	var targets []database.TargetTotals
-
-	err = db.Find(&targets).Error
-	if err != nil {
-		return fmt.Errorf("reading target totals: %w", err)
-	}
-
-	stats.Lifetime.Events = events.Events
-	stats.WithinRetention.Events = events.Events - events.EventsRemoved
-
-	for _, t := range targets {
-		stats.Lifetime.Deliveries += t.Deliveries
-		stats.Lifetime.Failures += t.Failed
-		stats.WithinRetention.Deliveries += t.Deliveries - t.DeliveriesRemoved
-		stats.WithinRetention.Failures += t.Failed - t.FailedRemoved
-	}
-
-	return nil
-}
-
-// readRecentWindow counts the events received, and the deliveries that
-// became delivered or failed, since the given time.
-func readRecentWindow(
-	db *gorm.DB, since time.Time,
-) (RecentWindow, error) {
-	var w RecentWindow
-
-	err := db.Model(&database.Event{}).
-		Where("created_at >= ?", since).
-		Count(&w.Events).Error
-	if err != nil {
-		return w, fmt.Errorf("counting recent events: %w", err)
-	}
-
-	byTarget, err := finishedByTarget(db, since)
-	if err != nil {
-		return w, err
-	}
-
-	for _, f := range byTarget {
-		w.Delivered += f.Delivered
-		w.Failed += f.Failed
-	}
-
-	return w, nil
-}
-
-// finishedByTarget counts, for each target, the deliveries that became
-// delivered and those that failed since the given time, in one query
-// over just that window of the deliveries' status index. A target with
-// neither is left out.
-func finishedByTarget(
-	db *gorm.DB, since time.Time,
-) ([]TargetFinished, error) {
-	var byTarget []TargetFinished
-
-	err := db.Model(&database.Delivery{}).
-		Select("target_id, "+
-			"count(CASE WHEN status = ? THEN 1 END) AS delivered, "+
-			"count(CASE WHEN status = ? THEN 1 END) AS failed",
-			database.DeliveryStatusDelivered,
-			database.DeliveryStatusFailed).
-		Where("status IN ? AND finished_at >= ?",
-			[]database.DeliveryStatus{
-				database.DeliveryStatusDelivered,
-				database.DeliveryStatusFailed,
-			}, since).
-		Group("target_id").
-		Find(&byTarget).Error
-	if err != nil {
-		return nil, fmt.Errorf(
-			"counting deliveries finished by target: %w", err,
-		)
-	}
-
-	return byTarget, nil
-}

internal/handlers/webhook_stats_test.go

@@ -1,442 +0,0 @@
-package handlers_test
-
-import (
-	"net/http"
-	"strings"
-	"testing"
-	"time"
-
-	"github.com/google/uuid"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"go.uber.org/fx/fxtest"
-	"gorm.io/gorm"
-	"gorm.io/gorm/clause"
-	"sneak.berlin/go/webhooker/internal/config"
-	"sneak.berlin/go/webhooker/internal/database"
-	"sneak.berlin/go/webhooker/internal/handlers"
-	"sneak.berlin/go/webhooker/internal/logger"
-	"sneak.berlin/go/webhooker/internal/session"
-)
-
-// statsEntrypoint adds an entrypoint to a webhook and returns its path.
-func statsEntrypoint(
-	t *testing.T, db *database.Database, webhookID string, active bool,
-) string {
-	t.Helper()
-
-	ep := &database.Entrypoint{
-		WebhookID: webhookID,
-		Path:      uuid.New().String(),
-	}
-
-	require.NoError(t, db.DB().Omit(clause.Associations).Create(ep).Error)
-	require.NoError(t, db.DB().Model(ep).Update("active", active).Error)
-
-	return ep.Path
-}
-
-// statsDelivery returns an event's delivery to a target.
-func statsDelivery(
-	t *testing.T, webhookDB *gorm.DB, eventID, targetID string,
-) database.Delivery {
-	t.Helper()
-
-	var d database.Delivery
-
-	require.NoError(t, webhookDB.Where(
-		"event_id = ? AND target_id = ?", eventID, targetID,
-	).First(&d).Error)
-
-	return d
-}
-
-// statsFinish settles a delivery as the delivery engine does: its
-// final status and the time it finished, and one more on its target's
-// delivered or failed total, in one transaction.
-func statsFinish(
-	t *testing.T,
-	webhookDB *gorm.DB,
-	d database.Delivery,
-	status database.DeliveryStatus,
-	at time.Time,
-) {
-	t.Helper()
-
-	add := database.TargetTotals{TargetID: d.TargetID, Delivered: 1}
-	if status == database.DeliveryStatusFailed {
-		add = database.TargetTotals{TargetID: d.TargetID, Failed: 1}
-	}
-
-	require.NoError(t, webhookDB.Transaction(func(tx *gorm.DB) error {
-		err := tx.Model(&database.Delivery{}).
-			Where("id = ?", d.ID).
-			Updates(map[string]any{"status": status, "finished_at": at}).
-			Error
-		if err != nil {
-			return err
-		}
-
-		return database.AddTargetTotals(tx, add)
-	}))
-}
-
-// statsAge moves an event's arrival back to the given time.
-func statsAge(
-	t *testing.T, webhookDB *gorm.DB, eventID string, at time.Time,
-) {
-	t.Helper()
-
-	require.NoError(t, webhookDB.Model(&database.Event{}).
-		Where("id = ?", eventID).
-		Update("created_at", at).Error)
-}
-
-// statsTargetTotals reads a webhook database's target totals, keyed by
-// target.
-func statsTargetTotals(
-	t *testing.T, webhookDB *gorm.DB,
-) map[string]database.TargetTotals {
-	t.Helper()
-
-	var rows []database.TargetTotals
-
-	require.NoError(t, webhookDB.Find(&rows).Error)
-
-	byTarget := make(map[string]database.TargetTotals, len(rows))
-	for _, row := range rows {
-		byTarget[row.TargetID] = row
-	}
-
-	return byTarget
-}
-
-// statsHistory is the webhook seedStatsHistory builds: its event
-// database, its newest event, and its two active targets.
-type statsHistory struct {
-	webhook       *database.Webhook
-	webhookDB     *gorm.DB
-	newest        database.Event
-	first, second string
-}
-
-// seedStatsHistory builds the webhook the statistics test checks: one
-// day of retention, two entrypoints (one inactive) and three targets
-// (one inactive). Three events arrive through the receiver, and so
-// each has a delivery to the two active targets. The oldest event is
-// past retention, the middle one six hours old, the newest just in.
-// Their deliveries are settled as the delivery engine would, and a
-// replay adds a pending delivery to the oldest event.
-func seedStatsHistory(
-	t *testing.T,
-	h *handlers.Handlers,
-	sess *session.Session,
-	db *database.Database,
-	dbMgr *database.WebhookDBManager,
-) statsHistory {
-	t.Helper()
-
-	wh := &database.Webhook{
-		UserID: deleteTestUserID, Name: "stats", RetentionDays: 1,
-	}
-	require.NoError(t, db.DB().Omit(clause.Associations).Create(wh).Error)
-
-	path := statsEntrypoint(t, db, wh.ID, true)
-	statsEntrypoint(t, db, wh.ID, false)
-
-	first := seedConfiguredTarget(
-		t, db, wh.ID, database.TargetTypeHTTP,
-		`{"url":"`+replayTargetURL+`"}`,
-	)
-	second := seedTarget(t, db, wh.ID, database.TargetTypeLog)
-	inactive := seedTarget(t, db, wh.ID, database.TargetTypeLog)
-	require.NoError(t, db.DB().Model(inactive).
-		Update("active", false).Error)
-
-	router := receiverRouter(h)
-
-	for range 3 {
-		require.Equal(t, http.StatusOK, postReceiver(t, router, path))
-	}
-
-	webhookDB, err := dbMgr.GetDB(wh.ID)
-	require.NoError(t, err)
-
-	events := listEvents(t, webhookDB)
-	require.Len(t, events, 3)
-
-	oldest, middle, newest := events[0], events[1], events[2]
-	now := time.Now()
-
-	statsAge(t, webhookDB, oldest.ID, now.Add(-50*time.Hour))
-	statsAge(t, webhookDB, middle.ID, now.Add(-6*time.Hour))
-
-	oldestFailure := statsDelivery(t, webhookDB, oldest.ID, first.ID)
-	statsFinish(t, webhookDB, oldestFailure,
-		database.DeliveryStatusFailed, now.Add(-49*time.Hour))
-	statsFinish(t, webhookDB,
-		statsDelivery(t, webhookDB, oldest.ID, second.ID),
-		database.DeliveryStatusDelivered, now.Add(-49*time.Hour))
-	statsFinish(t, webhookDB,
-		statsDelivery(t, webhookDB, middle.ID, first.ID),
-		database.DeliveryStatusFailed, now.Add(-5*time.Hour))
-	statsFinish(t, webhookDB,
-		statsDelivery(t, webhookDB, middle.ID, second.ID),
-		database.DeliveryStatusFailed, now.Add(-time.Minute))
-	statsFinish(t, webhookDB,
-		statsDelivery(t, webhookDB, newest.ID, first.ID),
-		database.DeliveryStatusDelivered, now.Add(-2*time.Minute))
-
-	require.Equal(t, http.StatusSeeOther,
-		postReplay(t, h, sess, wh.ID, oldestFailure.ID).Code)
-
-	return statsHistory{
-		webhook:   wh,
-		webhookDB: webhookDB,
-		newest:    newest,
-		first:     first.ID,
-		second:    second.ID,
-	}
-}
-
-// statsPrune runs the real retention reaper until it has removed one
-// event from the webhook's database, then stops it.
-func statsPrune(
-	t *testing.T,
-	db *database.Database,
-	dbMgr *database.WebhookDBManager,
-	log *logger.Logger,
-	webhookDB *gorm.DB,
-) {
-	t.Helper()
-
-	lc := fxtest.NewLifecycle(t)
-	database.NewRetentionReaper(lc, database.RetentionReaperParams{
-		Config: &config.Config{
-			RetentionSweepInterval: 10 * time.Millisecond,
-		},
-		Database:  db,
-		DBManager: dbMgr,
-		Logger:    log,
-	})
-
-	lc.RequireStart()
-
-	require.Eventually(t, func() bool {
-		var totals database.EventTotals
-
-		err := webhookDB.Take(&totals).Error
-
-		return err == nil && totals.EventsRemoved == 1
-	}, 10*time.Second, 10*time.Millisecond)
-
-	lc.RequireStop()
-}
-
-// statsPane returns the statistics pane from a rendered webhook page:
-// everything from its heading to the next heading on the page.
-func statsPane(t *testing.T, page string) string {
-	t.Helper()
-
-	_, pane, found := strings.Cut(page, ">Statistics</h2>")
-	require.True(t, found, "the page has no statistics pane")
-
-	pane, _, _ = strings.Cut(pane, "<h2")
-
-	return pane
-}
-
-// assertStatsTargets checks, for the history seedStatsHistory builds,
-// each target's totals and its deliveries finished in the last 24
-// hours. The first target has three deliveries and the replay, the
-// second three; the inactive target has none and so no row.
-func assertStatsTargets(t *testing.T, hist statsHistory) {
-	t.Helper()
-
-	first, second := hist.first, hist.second
-
-	assert.Equal(t, map[string]database.TargetTotals{
-		first: {TargetID: first, Deliveries: 4, Delivered: 1, Failed: 2},
-		second: {
-			TargetID: second, Deliveries: 3, Delivered: 1, Failed: 1,
-		},
-	}, statsTargetTotals(t, hist.webhookDB))
-
-	lastDay, err := handlers.FinishedByTargetForTest(
-		hist.webhookDB, time.Now().Add(-24*time.Hour),
-	)
-	require.NoError(t, err)
-	assert.ElementsMatch(t, []handlers.TargetFinished{
-		{TargetID: first, Delivered: 1, Failed: 1},
-		{TargetID: second, Failed: 1},
-	}, lastDay)
-}
-
-// TestWebhookStats_EveryFigureAcrossRetentionPrune checks every figure
-// the statistics pane shows for the history seedStatsHistory builds,
-// and each target's totals and recent figures, before and after the
-// real retention reaper removes the oldest event.
-func TestWebhookStats_EveryFigureAcrossRetentionPrune(t *testing.T) {
-	t.Parallel()
-
-	var (
-		h     *handlers.Handlers
-		sess  *session.Session
-		db    *database.Database
-		dbMgr *database.WebhookDBManager
-		log   *logger.Logger
-	)
-
-	app := newTestApp(t, &h, &sess, &db, &dbMgr, &log)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	hist := seedStatsHistory(t, h, sess, db, dbMgr)
-	first, second := hist.first, hist.second
-
-	stats := h.WebhookStatsForTest(hist.webhook.ID)
-	require.NotNil(t, stats)
-
-	assert.Equal(t, 2, stats.Entrypoints)
-	assert.Equal(t, 1, stats.ActiveEntrypoints)
-	assert.Equal(t, 3, stats.Targets)
-	assert.Equal(t, 2, stats.ActiveTargets)
-	assert.Equal(t, handlers.Counts{Events: 3, Deliveries: 7, Failures: 3},
-		stats.Lifetime)
-	assert.Equal(t, stats.Lifetime, stats.WithinRetention)
-	assert.Equal(t, int64(2), stats.InProgress)
-	require.NotNil(t, stats.LastEventAt)
-	assert.True(t, hist.newest.CreatedAt.Equal(*stats.LastEventAt))
-	assert.Equal(t, handlers.RecentWindow{
-		Events: 1, Delivered: 1, Failed: 1,
-	}, stats.Last10Minutes)
-	assert.Equal(t, handlers.RecentWindow{
-		Events: 2, Delivered: 1, Failed: 2,
-	}, stats.Last24Hours)
-	assert.Equal(t, "50.0%", stats.Last10Minutes.FailurePercent())
-	assert.Equal(t, "66.7%", stats.Last24Hours.FailurePercent())
-
-	assertStatsTargets(t, hist)
-
-	// Retention removes the oldest event with its three deliveries:
-	// the first target's failed one and the pending replay, and the
-	// second target's delivered one.
-	statsPrune(t, db, dbMgr, log, hist.webhookDB)
-
-	after := h.WebhookStatsForTest(hist.webhook.ID)
-	require.NotNil(t, after)
-
-	assert.Equal(t, stats.Lifetime, after.Lifetime)
-	assert.Equal(t, handlers.Counts{Events: 2, Deliveries: 4, Failures: 2},
-		after.WithinRetention)
-	assert.Equal(t, int64(1), after.InProgress)
-	assert.Equal(t, stats.LastEventAt, after.LastEventAt)
-	assert.Equal(t, stats.Last10Minutes, after.Last10Minutes)
-	assert.Equal(t, stats.Last24Hours, after.Last24Hours)
-
-	assert.Equal(t, map[string]database.TargetTotals{
-		first: {
-			TargetID: first, Deliveries: 4, Delivered: 1, Failed: 2,
-			DeliveriesRemoved: 2, FailedRemoved: 1,
-		},
-		second: {
-			TargetID: second, Deliveries: 3, Delivered: 1, Failed: 1,
-			DeliveriesRemoved: 1,
-		},
-	}, statsTargetTotals(t, hist.webhookDB))
-
-	pane := statsPane(t, renderSourceDetailPage(t, h, sess, hist.webhook.ID))
-	assert.Contains(t, pane, "Within retention")
-	assert.Contains(t, pane, "50.0%")
-	assert.Contains(t, pane, "66.7%")
-}
-
-// TestWebhookStats_PaneShowsRetentionPeriod checks that the statistics
-// pane itself, not only the line at the foot of the page, shows the
-// webhook's retention period, for a finite one and for forever.
-func TestWebhookStats_PaneShowsRetentionPeriod(t *testing.T) {
-	t.Parallel()
-
-	var (
-		h    *handlers.Handlers
-		sess *session.Session
-		db   *database.Database
-	)
-
-	app := newTestApp(t, &h, &sess, &db)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	tests := []struct {
-		retentionDays int
-		want          string
-	}{
-		{30, "30 days"},
-		{database.RetentionForeverDays, "forever"},
-	}
-
-	for _, tt := range tests {
-		wh := &database.Webhook{
-			UserID:        deleteTestUserID,
-			Name:          "retention",
-			RetentionDays: tt.retentionDays,
-		}
-		require.NoError(t,
-			db.DB().Omit(clause.Associations).Create(wh).Error)
-
-		pane := statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
-		assert.Contains(t, pane, "Retention", tt.want)
-		assert.Contains(t, pane, tt.want)
-	}
-}
-
-// TestWebhookStats_WebhookWithNoEvents covers a webhook whose event
-// database has never been opened: every count is zero, the
-// percentages are a dash, and showing the page does not create the
-// database.
-func TestWebhookStats_WebhookWithNoEvents(t *testing.T) {
-	t.Parallel()
-
-	var (
-		h     *handlers.Handlers
-		sess  *session.Session
-		db    *database.Database
-		dbMgr *database.WebhookDBManager
-	)
-
-	app := newTestApp(t, &h, &sess, &db, &dbMgr)
-	app.RequireStart()
-
-	t.Cleanup(app.RequireStop)
-
-	wh := seedWebhook(t, db)
-
-	assert.Equal(t, &handlers.WebhookStats{}, h.WebhookStatsForTest(wh.ID))
-	assert.Equal(t, "—", handlers.RecentWindow{}.FailurePercent())
-
-	statsPane(t, renderSourceDetailPage(t, h, sess, wh.ID))
-	assert.False(t, dbMgr.DBExists(wh.ID))
-}
-
-// TestRecentWindow_FailurePercent pins the percentage: failed
-// deliveries out of all that finished in the window.
-func TestRecentWindow_FailurePercent(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		window handlers.RecentWindow
-		want   string
-	}{
-		{handlers.RecentWindow{}, "—"},
-		{handlers.RecentWindow{Events: 4}, "—"},
-		{handlers.RecentWindow{Delivered: 3, Failed: 1}, "25.0%"},
-		{handlers.RecentWindow{Failed: 2}, "100.0%"},
-		{handlers.RecentWindow{Delivered: 2}, "0.0%"},
-	}
-
-	for _, tt := range tests {
-		assert.Equal(t, tt.want, tt.window.FailurePercent(), tt.window)
-	}
-}

internal/server/static_assets_test.go

@@ -13,9 +13,9 @@ import (
 
 // TestBaseTemplateScriptsAreServed walks every /s/ script the base
 // template loads on each page and fetches it through the real router.
-// Alpine.js is extracted from its tarball in 3p/ at build time, so the
+// Alpine.js is fetched at build time rather than committed, so nothing
-// file is not in the tree: this is the check that the page still gets
+// in the repo guarantees it is present: this is the check that the page
-// the JavaScript it asks for.
+// still gets the JavaScript it asks for.
 func TestBaseTemplateScriptsAreServed(t *testing.T) {
 	t.Parallel()
 

script/assets

@@ -1,16 +0,0 @@
-#!/bin/sh
-# script/assets: extract Alpine.js from its npm package tarball, committed
-# in 3p/, to static/js/alpine.min.js, where go:embed reads it. The
-# extracted file is not committed. script/test, make build and make dev run
-# this first.
-set -eu
-
-ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
-
-main() {
-    cd "$ROOT"
-    tar -xzOf 3p/alpinejs-3.14.9.tgz package/dist/cdn.min.js \
-        >static/js/alpine.min.js
-}
-
-main "$@"

script/bootstrap

@@ -4,7 +4,9 @@
 # installed tools are skipped. Base tooling comes from nix, apt, brew,
 # or apk (detected in that order); assumes NOTHING is present (not git,
 # make, or go). golangci-lint is deliberately not installed: linting runs
-# only in docker, via script/lint and Dockerfile.lint.
+# only in docker, via script/lint and Dockerfile.lint. Finishes by running
+# script/fetch-assets, which installs the hash-pinned third-party browser
+# assets the repo does not commit.
 set -eu
 
 ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
@@ -67,6 +69,11 @@ main() {
 
     go mod download
 
+    # Third-party browser assets are not committed; fetch and verify them
+    # so a fresh clone can build and test.
+    if missing curl; then pkg_install curl curl curl curl; fi
+    "$ROOT/script/fetch-assets"
+
     echo "bootstrap complete"
 }
 

script/check

@@ -1,7 +1,6 @@
 #!/bin/sh
 # script/check: run all checks (test, lint, fmt-check). Our own
-# extension to scripts-to-rule-them-all.
+# extension to scripts-to-rule-them-all. Must not modify any files.
-# Writes only the ignored static/js/alpine.min.js, through script/test.
 # Generic: usually needs no adaptation.
 set -eu
 

script/fetch-assets

@@ -0,0 +1,104 @@
+#!/bin/sh
+# script/fetch-assets: download the third-party browser assets the web UI
+# ships and install them under static/. Minified bundles are not committed
+# (REPO_POLICIES.md: no build artifacts in version control), so the build
+# fetches them here. Every download is verified against a hardcoded sha256
+# before it is installed, and any mismatch aborts. Idempotent: an asset
+# already present with its pinned hash is left alone.
+set -eu
+
+ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
+
+# The sha256 of each installed asset lives in static/vendor.sha256, in
+# sha256sum(1) format, with paths relative to static/. That file is the
+# single source of truth: this script verifies against it, and
+# static/vendor_test.go asserts the bytes embedded into the binary match
+# it, so the hash cannot rot into a value nothing checks.
+MANIFEST="static/vendor.sha256"
+
+# Alpine.js 3.14.9, 2026-08-17. Fetched from registry.npmjs.org, the
+# publisher of record; the jsDelivr and unpkg copies are mirrors of this
+# same tarball. dist/cdn.min.js is the browser build Alpine publishes for
+# a <script> tag.
+ALPINE_VERSION="3.14.9"
+ALPINE_URL="https://registry.npmjs.org/alpinejs/-/alpinejs-${ALPINE_VERSION}.tgz"
+# sha256 of alpinejs-3.14.9.tgz
+ALPINE_TARBALL_SHA256="97dad7c0c81e659cfc8e7700055da9770f8186187cb9a8a76efb57e00d5ce52a"
+ALPINE_MEMBER="package/dist/cdn.min.js"
+ALPINE_DEST="js/alpine.min.js"
+
+sha256_of() {
+    if command -v sha256sum >/dev/null 2>&1; then
+        sha256sum "$1" | cut -d' ' -f1
+    else
+        shasum -a 256 "$1" | cut -d' ' -f1
+    fi
+}
+
+# expected_sha256 <path-relative-to-static>
+expected_sha256() {
+    awk -v want="$1" '$2 == want { print $1; found = 1 }
+        END { if (!found) exit 1 }' "$ROOT/$MANIFEST"
+}
+
+# verify <file> <expected-sha256> <what>
+verify() {
+    actual="$(sha256_of "$1")"
+    if [ "$actual" != "$2" ]; then
+        echo "fetch-assets: sha256 mismatch for $3" >&2
+        echo "  expected: $2" >&2
+        echo "  actual:   $actual" >&2
+        exit 1
+    fi
+}
+
+# up_to_date <path-relative-to-static> <expected-sha256>
+up_to_date() {
+    [ -f "$ROOT/static/$1" ] || return 1
+    [ "$(sha256_of "$ROOT/static/$1")" = "$2" ]
+}
+
+fetch_alpine() {
+    want="$(expected_sha256 "$ALPINE_DEST")"
+
+    if up_to_date "$ALPINE_DEST" "$want"; then
+        echo "fetch-assets: static/$ALPINE_DEST already at $want"
+        return 0
+    fi
+
+    echo "fetch-assets: fetching Alpine.js $ALPINE_VERSION from $ALPINE_URL"
+    tmp="$(mktemp -d)"
+    trap 'rm -rf "$tmp"' EXIT INT TERM
+    curl -fsSL -o "$tmp/alpine.tgz" "$ALPINE_URL"
+    verify "$tmp/alpine.tgz" "$ALPINE_TARBALL_SHA256" "alpinejs-${ALPINE_VERSION}.tgz"
+    tar -xzOf "$tmp/alpine.tgz" "$ALPINE_MEMBER" >"$tmp/alpine.min.js"
+    verify "$tmp/alpine.min.js" "$want" "$ALPINE_MEMBER from alpinejs-${ALPINE_VERSION}.tgz"
+
+    mkdir -p "$(dirname "$ROOT/static/$ALPINE_DEST")"
+    cp "$tmp/alpine.min.js" "$ROOT/static/$ALPINE_DEST"
+    rm -rf "$tmp"
+    trap - EXIT INT TERM
+    echo "fetch-assets: installed static/$ALPINE_DEST ($want)"
+}
+
+# Re-check every manifest entry against what is now on disk, so an entry
+# no script installs fails loudly instead of passing silently.
+verify_manifest() {
+    while read -r want path; do
+        case "$want" in '' | '#'*) continue ;; esac
+        if [ ! -f "$ROOT/static/$path" ]; then
+            echo "fetch-assets: $MANIFEST lists static/$path, which is missing" >&2
+            exit 1
+        fi
+        verify "$ROOT/static/$path" "$want" "static/$path"
+    done <"$ROOT/$MANIFEST"
+}
+
+main() {
+    cd "$ROOT"
+    fetch_alpine
+    verify_manifest
+    echo "fetch-assets: all assets in $MANIFEST verified"
+}
+
+main "$@"

script/test

@@ -28,7 +28,6 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd -P)"
 
 main() {
     cd "$ROOT"
-    "$ROOT/script/assets"
     go test -v -race -timeout 90s ./...
 }
 

static/vendor.sha256

@@ -0,0 +1 @@
+3ed1eed252488921df65e363d6715deb04d7f92aaedb9e52199fdf73cb1e0ad3  js/alpine.min.js

static/vendor_test.go

@@ -0,0 +1,92 @@
+package static_test
+
+import (
+	"bufio"
+	"crypto/sha256"
+	"encoding/hex"
+	"os"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"sneak.berlin/go/webhooker/static"
+)
+
+const manifestPath = "vendor.sha256"
+
+// fetchHint is appended to every failure here: the assets the manifest
+// covers are fetched by the build, not committed, so a fresh clone that
+// has not run script/fetch-assets fails this test and should be told why.
+const fetchHint = "run `script/fetch-assets` (or `make assets`) to install " +
+	"the pinned third-party assets"
+
+// TestVendoredAssetsMatchManifest asserts that every asset listed in
+// static/vendor.sha256 is embedded in the binary with exactly the pinned
+// bytes. script/fetch-assets verifies the same hashes at download time;
+// this test verifies them again on what actually ships, so a build that
+// skipped, cached, or subverted the fetch cannot produce a binary serving
+// unpinned third-party JavaScript.
+func TestVendoredAssetsMatchManifest(t *testing.T) {
+	t.Parallel()
+
+	entries := readManifest(t)
+	require.NotEmpty(t, entries, "%s lists no assets", manifestPath)
+
+	for path, want := range entries {
+		t.Run(path, func(t *testing.T) {
+			t.Parallel()
+
+			data, err := static.Static.ReadFile(path)
+			require.NoErrorf(
+				t, err,
+				"%s is listed in %s but is not embedded; %s",
+				path, manifestPath, fetchHint,
+			)
+
+			sum := sha256.Sum256(data)
+			got := hex.EncodeToString(sum[:])
+			require.Equalf(
+				t, want, got,
+				"embedded %s does not match its pinned sha256 in %s; %s",
+				path, manifestPath, fetchHint,
+			)
+		})
+	}
+}
+
+// readManifest parses static/vendor.sha256, which is in sha256sum(1)
+// format with paths relative to static/.
+func readManifest(t *testing.T) map[string]string {
+	t.Helper()
+
+	f, err := os.Open(manifestPath)
+	require.NoError(t, err, "opening %s", manifestPath)
+
+	defer func() { require.NoError(t, f.Close()) }()
+
+	entries := make(map[string]string)
+	scanner := bufio.NewScanner(f)
+
+	for scanner.Scan() {
+		line := strings.TrimSpace(scanner.Text())
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+
+		fields := strings.Fields(line)
+		require.Lenf(
+			t, fields, 2,
+			"%s: malformed entry %q, want \"<sha256>  <path>\"",
+			manifestPath, line,
+		)
+
+		sum, path := fields[0], fields[1]
+		require.Lenf(t, sum, 64, "%s: %q is not a sha256", manifestPath, sum)
+		entries[path] = sum
+	}
+
+	require.NoError(t, scanner.Err(), "reading %s", manifestPath)
+
+	return entries
+}

templates/profile.html

@@ -41,6 +41,10 @@
                     <dt class="w-32 text-sm font-medium text-gray-500">Username</dt>
                     <dd class="text-sm text-gray-900">{{.User.Username}}</dd>
                 </div>
+                <div class="flex">
+                    <dt class="w-32 text-sm font-medium text-gray-500">Account Type</dt>
+                    <dd class="text-sm text-gray-900">Standard User</dd>
+                </div>
             </dl>
         </div>
     </div>

templates/source_detail.html

@@ -24,8 +24,6 @@
         </div>
     </div>
 
-    {{template "webhook_stats" .}}
-
     <div class="grid grid-cols-1 lg:grid-cols-2 gap-6">
         <!-- Entrypoints -->
         <div class="card">

templates/webhook_stats.html

@@ -1,93 +0,0 @@
-{{define "webhook_stats"}}
-<!-- Statistics pane at the top of the webhook page. -->
-<div class="card mb-6">
-    <div class="p-4 border-b border-gray-200">
-        <h2 class="text-lg font-medium text-gray-900">Statistics</h2>
-    </div>
-    {{with .Stats}}
-    <div class="p-4 flex flex-wrap gap-6 text-sm border-b border-gray-200">
-        <div>
-            <span class="text-gray-500">Entrypoints</span>
-            <span class="font-medium text-gray-900">{{.Entrypoints}}</span>
-            <span class="text-gray-500">({{.ActiveEntrypoints}} active)</span>
-        </div>
-        <div>
-            <span class="text-gray-500">Targets</span>
-            <span class="font-medium text-gray-900">{{.Targets}}</span>
-            <span class="text-gray-500">({{.ActiveTargets}} active)</span>
-        </div>
-        <div>
-            <span class="text-gray-500">Deliveries in progress</span>
-            <span class="font-medium text-gray-900">{{.InProgress}}</span>
-        </div>
-        <div>
-            <span class="text-gray-500">Last event</span>
-            <span class="font-medium text-gray-900">{{with .LastEventAt}}{{.Format "2006-01-02 15:04:05 UTC"}}{{else}}none{{end}}</span>
-        </div>
-        <div>
-            <span class="text-gray-500">Retention</span>
-            <span class="font-medium text-gray-900">{{$.Webhook.RetentionLabel}}</span>
-        </div>
-    </div>
-    <div class="p-4 grid grid-cols-1 lg:grid-cols-2 gap-6 text-sm">
-        <table class="w-full text-center text-gray-900">
-            <thead>
-                <tr class="border-b border-gray-200 text-xs text-gray-500 uppercase tracking-wide">
-                    <th></th>
-                    <th class="py-2 font-medium">Lifetime</th>
-                    <th class="py-2 font-medium">Within retention</th>
-                </tr>
-            </thead>
-            <tbody>
-                <tr>
-                    <td class="py-2 text-left text-gray-600">Events</td>
-                    <td class="py-2">{{.Lifetime.Events}}</td>
-                    <td class="py-2">{{.WithinRetention.Events}}</td>
-                </tr>
-                <tr>
-                    <td class="py-2 text-left text-gray-600">Deliveries</td>
-                    <td class="py-2">{{.Lifetime.Deliveries}}</td>
-                    <td class="py-2">{{.WithinRetention.Deliveries}}</td>
-                </tr>
-                <tr>
-                    <td class="py-2 text-left text-gray-600">Failures</td>
-                    <td class="py-2">{{.Lifetime.Failures}}</td>
-                    <td class="py-2">{{.WithinRetention.Failures}}</td>
-                </tr>
-            </tbody>
-        </table>
-        <div>
-            <table class="w-full text-center text-gray-900">
-                <thead>
-                    <tr class="border-b border-gray-200 text-xs text-gray-500 uppercase tracking-wide">
-                        <th></th>
-                        <th class="py-2 font-medium">Last 10 minutes</th>
-                        <th class="py-2 font-medium">Last 24 hours</th>
-                    </tr>
-                </thead>
-                <tbody>
-                    <tr>
-                        <td class="py-2 text-left text-gray-600">Events</td>
-                        <td class="py-2">{{.Last10Minutes.Events}}</td>
-                        <td class="py-2">{{.Last24Hours.Events}}</td>
-                    </tr>
-                    <tr>
-                        <td class="py-2 text-left text-gray-600">Failures</td>
-                        <td class="py-2">{{.Last10Minutes.Failed}}</td>
-                        <td class="py-2">{{.Last24Hours.Failed}}</td>
-                    </tr>
-                    <tr>
-                        <td class="py-2 text-left text-gray-600">Failure percentage</td>
-                        <td class="py-2">{{.Last10Minutes.FailurePercent}}</td>
-                        <td class="py-2">{{.Last24Hours.FailurePercent}}</td>
-                    </tr>
-                </tbody>
-            </table>
-            <p class="mt-2 text-xs text-gray-500">Failure percentage is the failed deliveries out of all deliveries that finished in the window. Deliveries still pending or retrying are not counted.</p>
-        </div>
-    </div>
-    {{else}}
-    <div class="p-4 text-sm text-gray-500">The statistics could not be read.</div>
-    {{end}}
-</div>
-{{end}}