Compare commits

..
Author SHA1 Message Date
Antigravity AI b54e58c99a chore: add fast-check property testing 2026-05-13 23:10:35 +12:00
63 changed files with 1132 additions and 4990 deletions

No files matched your search

-19
View File
@@ -1,29 +1,10 @@
name: CI
on:
push:
branches: [main]
pull_request:
branches: [main]
jobs:
# Non-blocking dependency audit. Surfaces high / critical vulnerabilities
# in the CI output without failing the build. Flip `continue-on-error` to
# `false` once the current transitive vulns (see #97) are resolved.
audit:
name: Dependency Audit
runs-on: ubuntu-latest
continue-on-error: true
steps:
- uses: actions/checkout@v6
- uses: pnpm/action-setup@v6
- uses: actions/setup-node@v6
with:
node-version: 22
cache: pnpm
- run: pnpm install --frozen-lockfile
- run: pnpm audit --audit-level high
typecheck:
name: Type Check
runs-on: ubuntu-latest
-53
View File
@@ -1,53 +0,0 @@
name: Mutation Testing
# Mutation testing is expensive (10–30 min per full run, even with
# `coverageAnalysis: "perTest"`), so we don't gate every PR on it.
# Instead it runs weekly so we catch drift in test quality, and on
# demand via workflow_dispatch when someone wants to validate a
# specific change.
on:
schedule:
# 03:00 UTC Monday = 10 PM US Eastern Sunday night.
- cron: '0 3 * * 1'
workflow_dispatch:
permissions:
contents: read
jobs:
stryker:
runs-on: ubuntu-latest
timeout-minutes: 60
steps:
- name: Checkout code
uses: actions/checkout@v4
with:
fetch-depth: 0 # Required for Stryker's incremental mode.
- name: Setup pnpm
uses: pnpm/action-setup@v3
with:
version: 9
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: 22
cache: pnpm
- name: Install dependencies
run: pnpm install --frozen-lockfile
- name: Generate Prisma client
run: pnpm exec prisma generate
- name: Run Stryker
run: pnpm exec stryker run
- name: Upload mutation report
if: always()
uses: actions/upload-artifact@v4
with:
name: stryker-report
path: reports/mutation/
retention-days: 30
-121
View File
@@ -1,121 +0,0 @@
name: Test Setup Scripts
on:
push:
branches: [ "main" ]
pull_request:
branches: [ "main" ]
permissions:
contents: read
jobs:
test-bash:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.x'
- name: Start local HTTP server
run: |
python3 -m http.server 8080 &
sleep 2 # Wait for server to start
- name: Patch setup.sh to use local server
run: |
sed -i 's|https://raw.githubusercontent.com/silvertakana/worldwideview/main|http://localhost:8080|g' self-host/setup.sh
- name: Run setup.sh
run: |
cd self-host
bash setup.sh
- name: Verify .env generation
run: |
cd self-host
if [ ! -f .env ]; then
echo ".env file was not created"
exit 1
fi
if ! grep -q "^AUTH_SECRET=[a-f0-9]\{64\}$" .env; then
echo "AUTH_SECRET was not generated correctly or is missing"
exit 1
fi
- name: Verify docker-compose.yml download
run: |
cd self-host
if [ ! -f docker-compose.yml ]; then
echo "docker-compose.yml was not downloaded"
exit 1
fi
- name: Verify Docker containers are running
run: |
cd self-host
docker compose ps
if ! docker compose ps | grep -q "Up"; then
echo "Docker containers failed to start"
exit 1
fi
test-powershell:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.x'
- name: Start local HTTP server
run: |
python3 -m http.server 8080 &
sleep 2 # Wait for server to start
- name: Patch setup.ps1 to use local server
run: |
sed -i 's|https://raw.githubusercontent.com/silvertakana/worldwideview/main|http://localhost:8080|g' self-host/setup.ps1
- name: Run setup.ps1
run: |
cd self-host
pwsh ./setup.ps1
- name: Verify .env generation
run: |
cd self-host
if [ ! -f .env ]; then
echo ".env file was not created"
exit 1
fi
if ! grep -q "^AUTH_SECRET=[a-f0-9]\{64\}$" .env; then
echo "AUTH_SECRET was not generated correctly or is missing"
exit 1
fi
- name: Verify docker-compose.yml download
run: |
cd self-host
if [ ! -f docker-compose.yml ]; then
echo "docker-compose.yml was not downloaded"
exit 1
fi
- name: Verify Docker containers are running
run: |
cd self-host
docker compose ps
if ! docker compose ps | grep -q "Up"; then
echo "Docker containers failed to start"
exit 1
fi
+70 -9
View File
@@ -37,17 +37,78 @@ Our primary design, feature-set, and operational layout goal is to mimic the str
## 4. Architecture Patterns
> [!NOTE]
> See [`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the human-facing architecture deep-dive — plugin system, state management, data pipeline, data engine & seeders, rendering pipeline, and edition system.
### 4.1 Plugin System (Core Abstraction)
Key invariants agents MUST respect:
Every data source is a **plugin** implementing the `WorldPlugin` interface from `@worldwideview/wwv-plugin-sdk`. The lifecycle utilizes a real-time WebSocket Firehose pipeline:
- **Plugin source of truth**: `@worldwideview/wwv-plugin-sdk` — never define plugin types locally.
- **All-Bundle Model**: every plugin (seeder, CDN-loaded, static-compiled, active-proxied) is dynamically imported via `loadPluginFromManifest` using `import(/* webpackIgnore: true */ entry)`. Legacy `StaticDataPlugin` / `DeclarativePlugin` runtimes are deprecated.
- **Agnostic frontend**: the renderer has no concept of a "unified" data engine. Each plugin **MUST declare its own `streamUrl`** in its manifest or config; do not assume one shared pipe.
- **Nine Zustand slices** under `src/core/state/`: `globe`, `layers`, `timeline`, `ui`, `filter`, `data`, `config`, `favorites`, `geojson`. Access via `useStore` in React, `useStore.getState()` elsewhere.
- **Primitive-based rendering** (not Cesium Entity API). Point/Billboard/Label/Polyline collections only. Never mix `size`/`outlineWidth`/`outlineColor` onto billboard entities — GPU silently clips.
- **Three editions** controlled by `NEXT_PUBLIC_WWV_EDITION` (`local` / `cloud` / `demo`); feature flags derived in `src/core/edition.ts`.
```text
PluginRegistry.register() → PluginManager.registerPlugin()
→ plugin.initialize(context)
Visibility Toggle → DataBusSubscriber subscribes to layer via WsClient
→ Engine responds with instantaneous websocket snapshots over /stream
→ WsClient pipes to DataBus.emit("dataUpdated", WsStreamPayload)
→ Store → EntityRenderer → Globe
```
Four plugin architectures exist (All-Bundle Model):
1. **Data Engine Seeder** — Lightweight `seeder.mjs` script executed by the dynamic `wwv-data-engine` runner (previously standalone microservices).
2. **Dynamic CDN Loaded (Bundle)** — Externally developed plugins dynamically imported at runtime via ES module CDNs (e.g., `unpkg.com` version-pinned URLs).
3. **Static Compiled (Bundle)** — Static GeoJSON data wrapped into JS bundles via `wwvStaticCompiler` during build/sync (previously `StaticDataPlugin`).
4. **Active Proxied (Bundle)** — Next.js API routes bundled to provide frontend interactions (previously `DeclarativePlugin`).
All plugins are now dynamically imported at runtime as ES module bundles via `loadPluginFromManifest` utilizing `import(/* webpackIgnore: true */ entry)`. The legacy `StaticDataPlugin` and `DeclarativePlugin` runtimes are fully deprecated.
Plugin types are re-exported from SDK through `src/core/plugins/PluginTypes.ts` and `PluginManifest.ts` — **source of truth is always `@worldwideview/wwv-plugin-sdk`**.
### 4.2 State Management
Zustand store with **nine slices**: `globe`, `layers`, `timeline`, `ui`, `filter`, `data`, `config`, `favorites`, `geojson`. Each slice is in its own file under `src/core/state/`.
- Access via `useStore` hook or `useStore.getState()` outside React
- Plugin settings stored in `configSlice.dataConfig.pluginSettings`
- Polling intervals stored in `configSlice.dataConfig.pollingIntervals`
### 4.3 Data Pipeline
```text
Engine push /stream → DataBusSubscriber WsClient router
→ WsClient.handleMessage() → DataBus.emit("websocketData")
→ DataBusSubscriber → _hydrateSnapshot() → Store.entitiesByPlugin
→ GlobeView (memoized visible entities)
→ EntityRenderer (billboard/point primitives)
→ AnimationLoop (horizon culling, hover/selection)
→ StackManager (co-located entity grouping)
```
### 4.3.1 Engine & Seeders Architecture
The data engine is a **content-agnostic runner** (`wwv-data-engine`, public) that discovers and executes seeder scripts from a configurable directory.
- **Local Dev**: Engine runs via Docker Compose on port 5000, reading seeders dynamically from `local-seeders/` (split into `community` and `private` tiers).
- **Production**: Engine container on Coolify, downloads release bundles from `wwv-seeders-community` and `wwv-seeders-private` on startup and unzips them into `/app/seeders`.
- **Split-routing**: `resolveEngineUrl` prioritizes the **Local Dev Engine (localhost:5001)** for local testing (following 12-Factor App methodology), falling back to cloud-hosted endpoints.
- **Agnostic Frontend Architecture**: WorldWideView is a completely agnostic renderer. It has absolutely no concept of a "unified" Data Engine. If 30 plugins require 30 different WebSocket servers, the application will blindly open 30 connections.
- **Self-Contained Plugins**: Each plugin is a self-contained package and **MUST explicitly declare its own `streamUrl` in its manifest or config**. Do NOT assume the frontend acts as a unified pipe. It just so happens that our default plugins share the `wwv-data-engine` backend, but the platform is 100% decentralized.
- **Dual-Output Engine**: Each seeder automatically exposes a WebSocket stream (`/stream`) and a REST API endpoint (`/api/[plugin-id]`).
- **Scope Boundary (99% vs 1%)**: The engine handles standard caching and broadcasting (99%). Plugins requiring complex on-demand compute (1%) must host their own custom backend.
### 4.4 Rendering Pipeline
- **Primitive-based**: Uses `PointPrimitiveCollection`, `BillboardCollection`, `LabelCollection` — NOT Cesium Entity API
- **Chunked processing**: Large datasets (10k+) rendered via `ChunkedProcessor`
- **LOD system**: Model-type entities promoted to 3D models at close range (`useModelRendering`)
- **Horizon culling**: Manual dot-product calculation against Earth radius (NOT depth testing)
- **Stack/Spiderifier**: `StackManager` groups co-located entities; `stackAnimation` handles expansion
### 4.5 Edition System
Three editions controlled by `NEXT_PUBLIC_WWV_EDITION`:
- **`local`** — Self-hosted, full features, auth enabled
- **`cloud`** — Managed cloud instance, full features
- **`demo`** — Public demo, auth disabled, optional admin via `WWV_DEMO_ADMIN_SECRET`
Feature flags derived from edition in `src/core/edition.ts`.
---
-42
View File
@@ -30,9 +30,6 @@ ARG NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL
ARG NEXT_PUBLIC_ADSENSE_CLIENT_ID
ARG NEXT_PUBLIC_SUPABASE_URL
ARG NEXT_PUBLIC_SUPABASE_ANON_KEY
ARG NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED
ARG NEXT_PUBLIC_WWV_BUILD_ID
ARG NEXT_PUBLIC_WWV_BUILD_AT
# Run our pregenerate schema swap script and then generate Prisma client
RUN NEXT_PUBLIC_WWV_EDITION=$NEXT_PUBLIC_WWV_EDITION pnpm run generate
@@ -40,41 +37,6 @@ RUN NEXT_PUBLIC_WWV_EDITION=$NEXT_PUBLIC_WWV_EDITION pnpm run generate
# Database migrations run at container startup via docker-entrypoint.sh
# DATABASE_URL must be set to a PostgreSQL connection string
# Stamp the build with a millisecond-precision id + iso timestamp. If the
# operator hasn't passed NEXT_PUBLIC_WWV_BUILD_ID via build args, generate
# one here so /api/build and the client console.log both carry a unique
# value per `docker build`.
RUN if [ -z "$NEXT_PUBLIC_WWV_BUILD_ID" ]; then \
NEXT_PUBLIC_WWV_BUILD_ID="$(date +%s%3N 2>/dev/null || node -e 'process.stdout.write(String(Date.now()))')" ; \
fi && \
if [ -z "$NEXT_PUBLIC_WWV_BUILD_AT" ]; then \
NEXT_PUBLIC_WWV_BUILD_AT="$(node -e 'process.stdout.write(new Date().toISOString())')" ; \
fi && \
echo "$NEXT_PUBLIC_WWV_BUILD_ID" > /app/.build-id && \
echo "$NEXT_PUBLIC_WWV_BUILD_AT" > /app/.build-at
# Write .env.production.local so Next.js sees every NEXT_PUBLIC_* var
# whose ARG was passed in. Docker doesn't reliably promote ARGs into the
# build process's environment for `next build` to inline references with
# Webpack's DefinePlugin — `process.env.NEXT_PUBLIC_X` either gets the
# inlined literal value (when set) or stays as a runtime polyfill access
# that resolves to undefined in the browser. Writing the file is the
# documented Next.js path and behaves the same on every host.
RUN set +e ; { \
echo "NEXT_PUBLIC_WWV_BUILD_ID=$(cat /app/.build-id)" ; \
echo "NEXT_PUBLIC_WWV_BUILD_AT=$(cat /app/.build-at)" ; \
if [ -n "$NEXT_PUBLIC_WWV_EDITION" ]; then echo "NEXT_PUBLIC_WWV_EDITION=$NEXT_PUBLIC_WWV_EDITION" ; fi ; \
if [ -n "$NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED" ]; then echo "NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED=$NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED" ; fi ; \
if [ -n "$NEXT_PUBLIC_CESIUM_ION_TOKEN" ]; then echo "NEXT_PUBLIC_CESIUM_ION_TOKEN=$NEXT_PUBLIC_CESIUM_ION_TOKEN" ; fi ; \
if [ -n "$NEXT_PUBLIC_GOOGLE_MAPS_API_KEY" ]; then echo "NEXT_PUBLIC_GOOGLE_MAPS_API_KEY=$NEXT_PUBLIC_GOOGLE_MAPS_API_KEY" ; fi ; \
if [ -n "$NEXT_PUBLIC_BING_MAPS_KEY" ]; then echo "NEXT_PUBLIC_BING_MAPS_KEY=$NEXT_PUBLIC_BING_MAPS_KEY" ; fi ; \
if [ -n "$NEXT_PUBLIC_WS_ENGINE_URL" ]; then echo "NEXT_PUBLIC_WS_ENGINE_URL=$NEXT_PUBLIC_WS_ENGINE_URL" ; fi ; \
if [ -n "$NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL" ]; then echo "NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL=$NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL" ; fi ; \
if [ -n "$NEXT_PUBLIC_ADSENSE_CLIENT_ID" ]; then echo "NEXT_PUBLIC_ADSENSE_CLIENT_ID=$NEXT_PUBLIC_ADSENSE_CLIENT_ID" ; fi ; \
if [ -n "$NEXT_PUBLIC_SUPABASE_URL" ]; then echo "NEXT_PUBLIC_SUPABASE_URL=$NEXT_PUBLIC_SUPABASE_URL" ; fi ; \
if [ -n "$NEXT_PUBLIC_SUPABASE_ANON_KEY" ]; then echo "NEXT_PUBLIC_SUPABASE_ANON_KEY=$NEXT_PUBLIC_SUPABASE_ANON_KEY" ; fi ; \
} > /app/.env.production.local
# Run Next.js build with Webpack cache mounted
RUN --mount=type=cache,target=/app/.next/cache NODE_OPTIONS="--max_old_space_size=3072" pnpm run build
RUN node scripts/copy-cesium.mjs
@@ -117,10 +79,6 @@ COPY --from=builder /app/.next/static ./.next/static
COPY --from=builder /app/public ./public
COPY --from=builder /app/scripts/https-proxy.mjs ./scripts/https-proxy.mjs
# Build stamp — read by /api/build at runtime.
COPY --from=builder /app/.build-id ./.build-id
COPY --from=builder /app/.build-at ./.build-at
# Entrypoint: migrate DB on first run, then start server
COPY docker-entrypoint.sh ./docker-entrypoint.sh
RUN sed -i 's/\r$//' ./docker-entrypoint.sh
+3 -6
View File
@@ -36,7 +36,6 @@ WorldWideView is a real-time geospatial engine visualizing live global data on a
- **Real-Time Data Pipeline**: High-frequency WebSocket updates managed by a custom `DataBus`.
- **Advanced Entity Management**: Automatic horizon culling, chunked primitive rendering, and 3D stacking/spiderification.
- **Marketplace Integration**: Download and sync new plugins directly from the UI.
- **Agent Bus (opt-in)**: HTTP+SSE control surface that lets an external tool — typically an MCP server fronting an LLM — fly the globe, toggle layers, and select entities in the running browser session. Default off; see [Agent Bus docs](docs/agent-bus.md).
## Core Technologies
@@ -87,13 +86,13 @@ WorldWideView uses a multi-stage Dockerfile designed for standalone output. To d
**Mac/Linux:**
```bash
mkdir worldwideview && cd worldwideview
curl -fsSL https://raw.githubusercontent.com/silvertakana/worldwideview/main/self-host/setup.sh | bash
curl -fsSL https://raw.githubusercontent.com/silvertakana/worldwideview/main/setup.sh | bash
```
**Windows (PowerShell):**
```powershell
mkdir worldwideview; cd worldwideview
Invoke-WebRequest -Uri https://raw.githubusercontent.com/silvertakana/worldwideview/main/self-host/setup.ps1 -UseBasicParsing | Invoke-Expression
Invoke-WebRequest -Uri https://raw.githubusercontent.com/silvertakana/worldwideview/main/setup.ps1 -UseBasicParsing | Invoke-Expression
```
> [!NOTE]
@@ -146,7 +145,6 @@ WorldWideView is distributed across several specialized repositories:
3. **`worldwideview-plugins`**: First-party maintained plugins.
4. **`worldwideview-marketplace`**: The web application driving the plugin directory.
5. **`worldwideview-web`**: Marketing and landing site.
6. **[`szski/wwv-mcp`](https://github.com/szski/wwv-mcp)**: Reference MCP server for driving the globe from an LLM agent (Claude Code, Claude Desktop, Cursor, Cline, …) via the [Agent Bus](docs/agent-bus.md). Contributor-hosted today; may move under the project org.
## Development & Workflow
@@ -169,12 +167,11 @@ This project is licensed under the Elastic License 2.0 - see the [LICENSE](LICEN
Explore our comprehensive documentation suite for detailed engineering insights:
- **[Project Overview](docs/project-overview.md)**: High-level value proposition and technology stack.
- **[Architecture](docs/ARCHITECTURE.md)**: Plugin system, state management, data pipeline, and Cesium rendering deep-dive.
- **[Architecture](docs/ARCHITECTURE.md)**: DataBus event stream and Zustand state management.
- **[Build System](docs/build-system.md)**: Monorepo structure, Next.js standalone output, and Docker builds.
- **[Development](docs/development.md)**: Coding conventions and common implementation patterns.
- **[Testing](docs/testing.md)**: Vitest setup and coverage targets.
- **[Deployment](docs/deployment.md)**: Coolify integration and persistent volumes.
- **[Agent Bus](docs/agent-bus.md)**: Wiring an MCP server (or any external tool) to drive the running globe.
- **[Files Catalog](docs/files.md)**: Comprehensive mapping of core source files.
> [!IMPORTANT]
+36
View File
@@ -0,0 +1,36 @@
services:
wwv:
build:
context: .
args:
- NEXT_PUBLIC_WWV_EDITION=${NEXT_PUBLIC_WWV_EDITION:-local}
- NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL=${NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL:-}
- NEXT_PUBLIC_SUPABASE_URL=${NEXT_PUBLIC_SUPABASE_URL:-}
- NEXT_PUBLIC_SUPABASE_ANON_KEY=${NEXT_PUBLIC_SUPABASE_ANON_KEY:-}
- NEXT_PUBLIC_GOOGLE_MAPS_API_KEY=${NEXT_PUBLIC_GOOGLE_MAPS_API_KEY:-}
- NEXT_PUBLIC_BING_MAPS_KEY=${NEXT_PUBLIC_BING_MAPS_KEY:-}
- NEXT_PUBLIC_CESIUM_ION_TOKEN=${NEXT_PUBLIC_CESIUM_ION_TOKEN:-}
- NEXT_PUBLIC_ADSENSE_CLIENT_ID=${NEXT_PUBLIC_ADSENSE_CLIENT_ID:-}
pull_policy: build
ports:
- "3000:3000"
db:
profiles:
- "${WWV_SKIP_LOCAL_DB:-}"
ports:
- "5432:5432"
wwv-data-engine:
command: >
sh -c "
echo 'Syncing workspace dependencies...' &&
cd $$SEEDERS_DIR/community && CI=true pnpm install --ignore-scripts && pnpm -r rebuild better-sqlite3 esbuild &&
if [ -d \"$$SEEDERS_DIR/private\" ]; then cd $$SEEDERS_DIR/private && CI=true pnpm install --ignore-scripts && pnpm -r rebuild better-sqlite3 esbuild; fi &&
cd /app && node dist/server.js"
ports:
- "5000:5000"
networks:
coolify:
external: true
+6 -12
View File
@@ -1,5 +1,6 @@
services:
wwv:
image: ghcr.io/silvertakana/worldwideview:latest
build:
context: .
args:
@@ -15,7 +16,6 @@ services:
- "3000:3000"
volumes:
- wwv-data:/app/data
- ./public/plugins-local:/app/public/plugins-local:ro
env_file:
- path: .env
required: false
@@ -55,22 +55,20 @@ services:
wwv-data-engine:
image: ghcr.io/silvertakana/wwv-data-engine:latest
command: >
sh -c "
echo 'Syncing workspace dependencies...' &&
cd $$SEEDERS_DIR/community && CI=true pnpm install --ignore-scripts && pnpm -r rebuild better-sqlite3 esbuild &&
if [ -d \"$$SEEDERS_DIR/private\" ]; then cd $$SEEDERS_DIR/private && CI=true pnpm install --ignore-scripts && pnpm -r rebuild better-sqlite3 esbuild; fi &&
cd /app && node dist/server.js"
ports:
- "5000:5000"
environment:
- PORT=5000
- REDIS_URL=redis://wwv-redis:6379
- SEEDERS_DIR=/app/seeders
- SEEDERS_DIR=/mnt/host/c/dev/worldwideview/local-seeders
- SKIP_SEEDER_DOWNLOAD=true
- DB_PATH=/app/data/engine.db
depends_on:
wwv-redis:
condition: service_healthy
volumes:
- ../wwv-seeders:/mnt/host/c/dev/worldwideview/local-seeders/community
- ../wwv-seeders-private:/mnt/host/c/dev/worldwideview/local-seeders/private
restart: unless-stopped
profiles:
- engine
@@ -85,10 +83,6 @@ services:
profiles:
- engine
networks:
coolify:
external: true
volumes:
wwv-data:
postgres-data:
+26 -193
View File
@@ -1,200 +1,33 @@
<!-- Generated: 2026-04-23 06:11:00 UTC -->
# Architecture
WorldWideView is a **real-time geospatial intelligence engine**: a Next.js 16 frontend that renders live global data on a CesiumJS 3D globe, fed by a network of independent data seeders streaming over WebSockets. The whole platform is built on an "All-Bundle" plugin architecture, so data sources are decoupled from the core viewer and can be added, removed, or hot-swapped without touching rendering code.
## Overview
WorldWideView operates on a decoupled, plugin-based architecture designed for real-time visualization of geospatial data. The system is split between a Next.js 16 frontend that handles UI and CesiumJS 3D rendering, and a network of plugin data seeders that stream live updates via WebSockets.
This document is the deep-dive companion to the [README](../README.md). It is intended for human contributors who want to understand how the pieces fit before opening their first PR. For agent-facing rules and conventions, see [`AGENTS.md`](../AGENTS.md) at the repo root and the documents under [`.agents/rules/`](../.agents/rules/).
The core design philosophy is the "All-Bundle Model," where plugins are dynamically imported at runtime as ES module bundles (`Dynamic CDN Loaded`). The frontend maintains a modular state architecture using Zustand, routing high-frequency data updates through a custom `DataBus` singleton to avoid React render cycle bottlenecks. WorldWideView is a completely agnostic renderer with absolutely no concept of a "unified" Data Engine; each plugin is a self-contained package that explicitly declares its own `streamUrl` in its manifest or config.
## System Overview
## Component Map
- **Frontend App Shell:** Next.js App Router providing layout and base API routes (in `src/app/`).
- **Globe Rendering Engine:** CesiumJS wrapped in Resium, responsible for 3D primitive and model rendering (in `src/core/globe/`).
- **State Management:** Zustand slice-based architecture (in `src/core/state/`).
- **Data Pipeline:** Custom event bus (`DataBus`) and WebSocket clients (`DataBusSubscriber`) routing live data to state (in `src/core/data/`).
- **Plugin System:** Registration, lifecycle management, and ES module loaders (in `src/core/plugins/`).
- **Database Layer:** Prisma ORM connecting to PostgreSQL (in `prisma/`).
```mermaid
flowchart TD
subgraph "Data Sources"
A[Public APIs] -->|Poll| B[Data Engine Seeders]
C[Custom Microservices] -->|Stream| B
end
## Key Files
- `src/core/plugins/PluginManager.ts` - The PluginManager class. Core registry that instantiates plugins, calls `initialize()`, and handles lifecycle events.
- `src/core/plugins/loaders/InstalledPluginsLoader.ts` - Dynamically fetches and imports `import(/* webpackIgnore: true */ ...)` marketplace plugins into the environment.
- `src/core/data/DataBus.ts` - Custom typed event bus singleton that routes high-frequency data around the application.
- `src/core/globe/GlobeView.tsx` - The main Cesium viewer container, handling imagery layers, cameras, and primitive collections.
- `src/core/state/store.ts` - The main Zustand store registry linking the nine state slices (globe, layers, timeline, ui, filter, data, config, favorites, geojson).
subgraph "Engine Tier"
B -->|WebSocket /stream| D[WsClient]
end
## Data Flow
Real-time data follows a strict unidirectional stream optimized for sub-second updates:
subgraph "Frontend Pipeline"
D --> E[DataBus<br/>typed pub/sub]
E -->|"_hydrateSnapshot()"| F[Zustand Store<br/>9 slices]
F -->|Memoized visible entities| G[EntityRenderer]
G -->|Primitive collections| H[CesiumJS Globe]
H --> I[AnimationLoop<br/>horizon culling + LOD]
end
subgraph "Plugin Layer"
J[PluginRegistry] -->|"loadPluginFromManifest"| K[Dynamic ES module imports]
J -.->|register| E
end
```
The strict unidirectional flow — engine → bus → store → renderer — is what lets the system push sub-second updates for thousands of entities without React render-cycle bottlenecks.
## Plugin System (Core Abstraction)
Every data source in WorldWideView is a **plugin** implementing the `WorldPlugin` interface from [`@worldwideview/wwv-plugin-sdk`](../packages/wwv-plugin-sdk/). The plugin's lifecycle plugs into a real-time WebSocket firehose:
```text
PluginRegistry.register() → PluginManager.registerPlugin()
→ plugin.initialize(context)
Visibility Toggle → DataBusSubscriber subscribes to layer via WsClient
→ Engine responds with instantaneous WebSocket snapshots over /stream
→ WsClient pipes to DataBus.emit("dataUpdated", WsStreamPayload)
→ Store → EntityRenderer → Globe
```
Four plugin architectures coexist under the "All-Bundle Model":
1. **Data Engine Seeder** — A lightweight `seeder.mjs` script run by the dynamic `wwv-data-engine` runner. (Previously a standalone microservice container; the runner replaces that.)
2. **Dynamic CDN Loaded (Bundle)** — Externally developed plugins, dynamically imported at runtime via ES module CDNs (e.g. version-pinned `unpkg.com` URLs).
3. **Static Compiled (Bundle)** — Static GeoJSON data wrapped into JS bundles via `wwvStaticCompiler` during build/sync. (Previously `StaticDataPlugin`.)
4. **Active Proxied (Bundle)** — Next.js API routes bundled to mediate frontend interactions. (Previously `DeclarativePlugin`.)
All four are now dynamically imported at runtime as ES module bundles via `loadPluginFromManifest`, which uses `import(/* webpackIgnore: true */ entry)`. The legacy `StaticDataPlugin` and `DeclarativePlugin` runtimes are fully deprecated.
> [!IMPORTANT]
> Plugin types are re-exported from the SDK through `src/core/plugins/PluginTypes.ts` and `src/core/plugins/PluginManifest.ts`. The **source of truth is always `@worldwideview/wwv-plugin-sdk`** — never define plugin types locally.
For the contributor checklist when authoring a plugin, see [`.agents/skills/worldwideview-plugin-creation/`](../.agents/skills/) and the [Plugin Quickstart](plugin-quickstart.md).
## State Management
WorldWideView uses a Zustand store split into **nine slices**, each in its own file under [`src/core/state/`](../src/core/state/):
| Slice | Responsibility |
|---|---|
| `globe` | Camera position, imagery layers, scene settings |
| `layers` | Per-plugin visibility toggles |
| `timeline` | Playback range, current time, play/pause |
| `ui` | Panel open/closed states, selected entity |
| `filter` | Plugin filter expressions, applied via `filterEngine` |
| `data` | Entity cache (`entitiesByPlugin`), websocket connection state |
| `config` | Plugin settings, polling intervals, API keys |
| `favorites` | User-bookmarked entities |
| `geojson` | Custom GeoJSON overlays |
Access patterns:
- React components: `const camera = useStore((s) => s.camera);`
- Outside React (animation loop, hooks setup): `const state = useStore.getState();`
- Plugin settings: `configSlice.dataConfig.pluginSettings[pluginId]`
- Polling intervals: `configSlice.dataConfig.pollingIntervals[pluginId]`
The animation loop deliberately snapshots state once per frame via `getState()` rather than subscribing — `requestAnimationFrame` is the loop driver, so adding a Zustand subscription would just duplicate ticks.
## Data Pipeline
Real-time data follows a strict unidirectional path optimised for sub-second updates:
```text
Engine push /stream → DataBusSubscriber WsClient router
→ WsClient.handleMessage() → DataBus.emit("websocketData", WsStreamPayload)
→ DataBusSubscriber → _hydrateSnapshot() → Store.entitiesByPlugin
→ GlobeView (memoised visible entities)
→ EntityRenderer (billboard/point primitives)
→ AnimationLoop (horizon culling, hover/selection)
→ StackManager (co-located entity grouping)
```
The `DataBus` is a custom typed pub/sub singleton (see [`src/core/data/DataBus.ts`](../src/core/data/DataBus.ts)). It exists specifically to bypass React's render cycle for high-frequency events — store updates are batched into the Zustand store, but raw stream events ride the bus directly.
## Data Engine & Seeders
The data engine ([`wwv-data-engine`](https://github.com/silvertakana/wwv-data-engine), public) is a **content-agnostic runner**. It discovers and executes seeder scripts from a configurable directory; the engine itself knows nothing about specific data sources.
- **Local development**: The engine runs via Docker Compose on port 5001, reading seeders dynamically from `local-seeders/` (split into `community` and `private` tiers).
- **Production**: The engine container on Coolify downloads release bundles from `wwv-seeders-community` and `wwv-seeders-private` on startup, unzipping them into `/app/seeders`.
- **Split-routing**: `resolveEngineUrl` prioritises the local dev engine (`ws://localhost:5001/stream`) for local testing — 12-Factor App methodology — and falls back to cloud-hosted endpoints (e.g. `wss://dataenginev2.worldwideview.dev/stream`) when nothing local is available.
### Agnostic Frontend
WorldWideView's frontend is a **completely agnostic renderer**. It has no concept of a "unified" data engine. If 30 plugins each declare a different `streamUrl`, the application opens 30 WebSocket connections; it just so happens that the default plugin set shares `wwv-data-engine`, but the platform is 100% decentralised.
> [!IMPORTANT]
> Each plugin is a self-contained package and **MUST explicitly declare its own `streamUrl` in its manifest or config.** Do not assume the frontend acts as a unified pipe.
### Dual-Output Engine
Each seeder automatically exposes both a WebSocket stream (`/stream`) and a REST API endpoint (`/api/[plugin-id]`). Plugins can consume either depending on their data shape — bursty / live → stream, slow-moving / on-demand → REST.
### Scope Boundary (the 99 / 1 Rule)
The engine handles standard caching and broadcasting — the 99% case. Plugins that require complex on-demand compute (the 1%) must host their own custom backend; the engine intentionally does not grow features for them.
## Rendering Pipeline
The renderer is where most of WorldWideView's engineering depth lives. Three design choices drive the performance envelope:
### Primitive-based rendering
We use [`PointPrimitiveCollection`](https://cesium.com/learn/cesiumjs/ref-doc/PointPrimitiveCollection.html), `BillboardCollection`, `LabelCollection`, and `PolylineCollection` directly — **not** the Cesium Entity API. The Entity API is convenient but allocates per-entity ECS-style state that gets expensive past a few thousand entities. Primitive collections batch their state into typed GPU buffers, so 10k+ live entities still hold 60 fps on a moderate laptop.
Collections are tracked per-viewer via a module-level `WeakMap<CesiumViewer, PrimitiveCollections>` in [`src/core/globe/EntityRenderer.ts`](../src/core/globe/EntityRenderer.ts), keeping the renderer multi-viewer-capable and ensuring collections GC cleanly when a viewer is torn down.
### Chunked processing
Large datasets (10k+ entities) are rendered via [`ChunkedProcessor`](../src/core/globe/ChunkedProcessor.ts) in 500-entity chunks across multiple microtasks, so adding a new plugin layer never blocks the main thread long enough to drop a frame.
### Horizon culling and LOD
The animation loop performs **manual horizon culling** in [`AnimationLoop.ts`](../src/core/globe/AnimationLoop.ts) using a single dot-product against the Earth radius — much cheaper than depth-testing thousands of primitives every frame, and tunable for "entities just below the horizon should still be visible" semantics that depth-testing can't express.
Entities of `type: "model"` are promoted to full 3D glTF models at close range via the LOD system in [`useModelRendering.ts`](../src/core/globe/hooks/useModelRendering.ts) — so an aircraft at 50 nm range is a tinted billboard, but at 5 nm it's a textured plane model with the right wing geometry.
### Stack / Spiderifier
When multiple entities share a screen-space cluster (busy ports, busy airspaces), [`StackManager`](../src/core/globe/StackManager.ts) groups them and [`stackAnimation`](../src/core/globe/stackAnimation.ts) handles the spiderification expansion when a stack is clicked.
### Entity-type rules
> [!WARNING]
> When returning `CesiumEntityOptions` from a plugin's `renderEntity()`:
>
> - **Points**: Use `type: "point"` with `color`, `size`, `outlineColor`, `outlineWidth`.
> - **Billboards**: Use `type: "billboard"` with `iconUrl`, `color`, `iconScale`.
> - **NEVER mix**: Do not set `size` / `outlineWidth` / `outlineColor` on a billboard — Cesium silently clips the GPU upload and the icon disappears.
## Edition System
WorldWideView ships in three editions, controlled by the `NEXT_PUBLIC_WWV_EDITION` environment variable. Feature flags are derived from this in [`src/core/edition.ts`](../src/core/edition.ts).
| Edition | Auth | Use case |
|---|---|---|
| `local` | Enabled (NextAuth credentials) | Self-hosted single-user / small-team deployments |
| `cloud` | Enabled | Managed cloud instance with multi-tenancy |
| `demo` | Disabled (optional admin via `WWV_DEMO_ADMIN_SECRET`) | Public demo deployments |
Edition isn't just an auth toggle — it also gates which marketplace endpoints are queried, which default plugins boot, and whether destructive admin actions are reachable.
## Key Source Files
Quick map of the load-bearing modules:
| Path | Role |
|---|---|
| [`src/core/plugins/PluginManager.ts`](../src/core/plugins/PluginManager.ts) | Core plugin registry. Instantiates plugins, calls `initialize()`, manages lifecycle. |
| [`src/core/plugins/loaders/InstalledPluginsLoader.ts`](../src/core/plugins/loaders/InstalledPluginsLoader.ts) | Dynamic ES module loader for marketplace plugins (`import(/* webpackIgnore: true */ entry)`). |
| [`src/core/data/DataBus.ts`](../src/core/data/DataBus.ts) | Typed pub/sub singleton — the high-frequency event channel. |
| [`src/core/data/WsClient.ts`](../src/core/data/WsClient.ts) | WebSocket router. Pipes engine `/stream` messages onto the DataBus. |
| [`src/core/globe/GlobeView.tsx`](../src/core/globe/GlobeView.tsx) | The Cesium viewer container. Imagery layers, camera setup, primitive collection wiring. |
| [`src/core/globe/EntityRenderer.ts`](../src/core/globe/EntityRenderer.ts) | Translates store entities into Cesium primitives. Hot path for 10k+ entities. |
| [`src/core/globe/AnimationLoop.ts`](../src/core/globe/AnimationLoop.ts) | Per-frame update: horizon culling, hover/selection, model LOD promotion. |
| [`src/core/state/store.ts`](../src/core/state/store.ts) | Zustand store registry linking the nine slices. |
## Further Reading
For deeper coverage of specific subsystems, see the rule files under [`.agents/rules/`](../.agents/rules/):
- [`platform-architecture.md`](../.agents/rules/platform-architecture.md) — high-level platform goals, product vision, Edition System
- [`application-architecture.md`](../.agents/rules/application-architecture.md) — Next.js frontend, Zustand, CesiumJS integration
- [`plugin-architecture.md`](../.agents/rules/plugin-architecture.md) — plugin lifecycle, capability declarations, seeders
- [`marketplace-architecture.md`](../.agents/rules/marketplace-architecture.md) — dynamic plugin installation, DB sync, CDN loading
- [`cesium-rendering.md`](../.agents/rules/cesium-rendering.md) — globe rendering, entity types, primitives, LOD, culling
- [`state-management.md`](../.agents/rules/state-management.md) — slice access patterns, plugin settings
- [`data-engine-architecture.md`](../.agents/rules/data-engine-architecture.md) — engine internals, seeder loading, workspace dependencies
For getting started as a contributor, see [Development](development.md), [Plugin Quickstart](plugin-quickstart.md), and [Plugin Advanced](plugin-advanced.md).
1. **Engine Push:** A remote data engine pushes state over WebSocket (`/stream`) from a custom backend or our default `DataEngineV2` runner. (Local dev defaults to `ws://localhost:5001/stream`, while cloud fallback is `wss://dataenginev2.worldwideview.dev/stream`). Seeders in Data Engine V2 expose both a WebSocket stream for real-time instantaneous updates and a REST API endpoint (`/api/:id`) for fetching live data snapshots.
2. **WebSocket Client Router:** `WsClient.handleMessage()` receives the payload and pipes it to the event bus.
3. **DataBus Emission:** The bus fires `DataBus.emit("websocketData", WsStreamPayload)`.
4. **State Hydration:** The `DataBusSubscriber` component listens to the bus and calls `_hydrateSnapshot()` to update the Zustand store's `entitiesByPlugin` cache.
5. **Memoized Selection:** `GlobeView` selects the visible entities from the store.
6. **Primitive Rendering:** The `EntityRenderer` translates store entities into Cesium `PointPrimitiveCollection` and `BillboardCollection` arrays for GPU rendering.
7. **Animation & LOD:** `AnimationLoop` handles horizon culling and hover effects, while `useModelRendering` promotes close-range entities to 3D glTF models.
-166
View File
@@ -1,166 +0,0 @@
# Agent Bus — driving WWV from external tools
## Overview
The Agent Bus is an opt-in HTTP+SSE surface that lets a trusted external process — most commonly a [Model Context Protocol](https://modelcontextprotocol.io) (MCP) server fronting an LLM agent — drive the running WWV browser session. The agent can fly the globe, toggle layers, focus entities, and select things by posting JSON actions to a server endpoint, which fans them out over SSE to every browser tab belonging to the same logged-in user.
Read-only camera and engine queries already work via the existing REST API. The Agent Bus is the missing **write path**.
```
LLM client ──MCP──▶ szski/wwv-mcp ──HTTP──▶ /api/agent/publish ──SSE──▶ browser
(Claude, Cursor, …) (separate repo) (this PR adds these) (Cesium flies)
```
## Enabling the bus
The bus is **off by default**. The subscriber early-returns and no SSE connection is opened. You explicitly opt in via a build-time environment variable.
### In Docker
Pass the ARG at build time:
```sh
docker build \
--build-arg NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED=true \
-t worldwideview .
```
### In a Coolify / hosted build
Set `NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED=true` in the build environment. Because it's a `NEXT_PUBLIC_*` variable, it is inlined into the JavaScript bundle at `next build` time — runtime-only env changes will not enable it.
### Verifying it's on
On a fresh page load, open the browser DevTools console. You should see a one-line build banner:
```
[wwv build] id=1714572934123 built_at=2026-05-13T18:35:34Z agent_bus=on
```
If `agent_bus=off` after enabling the env var, the build did not pick up the variable — re-check that it was passed as `--build-arg` (Docker) or set before `next build` ran (other hosts).
You can also hit `/api/build` to confirm the served bundle's build id and flag state.
## Using it — quick smoke test with curl
To verify the bus end-to-end without an MCP server, log into WWV in your browser, grab your `__Secure-authjs.session-token` cookie value from DevTools, and POST an action:
```sh
curl -X POST https://your-wwv-host/api/agent/publish \
-H "Content-Type: application/json" \
-H "Cookie: __Secure-authjs.session-token=PASTE_TOKEN_HERE" \
-d '{"action":"fly_to","lat":35.7796,"lon":-78.6382,"distance":50000}'
```
If the bus is enabled and the cookie is valid, the open tab will fly to Raleigh and the response will be:
```json
{ "ok": true, "delivered": 1, "subscribers": 1 }
```
`subscribers: 0` means the bus is off in the build, the cookie's user has no open tabs, or the env var wasn't applied — see *Verifying* above.
## Using it — wiring an MCP server
The reference MCP server for WWV is published at **[szski/wwv-mcp](https://github.com/szski/wwv-mcp)**. It exposes 15 tools (`globe_fly_to`, `layer_toggle`, `engine_query`, `geocode`, `system_status`, etc.) and works with any MCP-aware client (Claude Code, Claude Desktop, Cursor, Continue, Cline).
> [!NOTE]
> `szski/wwv-mcp` lives in a contributor's namespace today and may move under the project's own organization later. Update the install URL accordingly when that happens.
### Install (Node)
```sh
git clone https://github.com/szski/wwv-mcp
cd wwv-mcp
npm install
npm run build
```
Then store credentials so the MCP server can auto-login at startup:
```sh
mkdir -p ~/.config/wwv-mcp
cat > ~/.config/wwv-mcp/credentials <<'EOF'
[email protected]
WWV_PASSWORD=your-password
EOF
chmod 600 ~/.config/wwv-mcp/credentials
```
### Install (Docker)
If a published image exists at `szski/wwv-mcp` (or wherever the maintainer mirrors it), no install step is needed — the MCP client config below uses `docker run` to launch the server on demand.
### Client config — Claude Code
Edit `~/.claude/settings.json`:
```json
{
"mcpServers": {
"wwv": {
"command": "node",
"args": ["/absolute/path/to/wwv-mcp/dist/index.js"],
"env": {
"WWV_BASE_URL": "https://your-wwv-host.example",
"WWV_ENGINE_URL": "http://localhost:5001"
}
}
}
}
```
Or, with Docker:
```json
{
"mcpServers": {
"wwv": {
"command": "docker",
"args": [
"run", "-i", "--rm",
"-e", "WWV_BASE_URL=http://host.docker.internal:3000",
"-e", "WWV_ENGINE_URL=http://host.docker.internal:5001",
"szski/wwv-mcp:latest"
]
}
}
}
```
Then `/mcp` in Claude Code should list `wwv` with all 15 tools.
### Client config — Claude Desktop
Edit `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows). The `mcpServers.wwv` block is identical to Claude Code above.
### Client config — Cursor, Continue, Cline
Each of these reads an MCP server list in its own settings UI but the shape of the entry — `command` + `args` + `env` — is the same as Claude Code's. See your client's MCP docs for the exact location of its config file.
### Verifying the wiring
Once configured, ask the agent something like *"What's the status of the WWV system?"* — it should call `system_status` and report back. If you see `agent_bus_enabled: false`, the bus is off in the WWV build; fix that before trying write tools like `globe_fly_to`.
## Security and multi-tenancy
- **Default off.** Without the env var, the subscriber doesn't open a connection, the publish endpoint exists but has no subscribers, and the bundle's dead-code elimination removes the `EventSource` constructor entirely.
- **Auth gated.** Both `/api/agent/publish` and `/api/agent/stream` use the same `auth()` helper as the rest of the marketplace API. No tokens — just the existing Auth.js session cookie.
- **Per-user scoping.** Subscriptions live in `Map<userId, …>`, so a publish from user A's session never reaches user B's stream, even though both sit on the same Node process. Multi-tenant deployments are safe.
- **Same trust model as a browser tab.** An MCP server "acts as the user" by holding the user's session cookie. If you wouldn't trust a browser tab on the same machine, don't give an MCP server the cookie.
- **Single-process only.** The `AgentBus` is in-memory and process-local. Multi-instance deployments behind a load balancer would need a Redis pub/sub adapter — about 30 lines of additional code, not included here.
## Endpoint reference
| Method | Path | Purpose |
|---|---|---|
| `GET` | `/api/agent/stream` | SSE channel. Auth-gated. Streams `AgentAction` JSON events for the connected user. Heartbeat every 25s. |
| `POST` | `/api/agent/publish` | Accept an `AgentAction` JSON body, broadcast to the publishing user's subscribers, return `{ok, delivered, subscribers}`. |
| `GET` | `/api/build` | Build id + ISO timestamp + `NEXT_PUBLIC_*` flag state. Used by `AgentBusSubscriber` to print the build banner. |
`AgentAction` is currently a six-verb union: `fly_to`, `face_towards`, `layer_toggle`, `highlight_layer`, `select_entity`, `ping`. The shape is `{action: string, …payload}` JSON, so additive changes are backwards-compatible.
## Companion repos
- **[szski/wwv-mcp](https://github.com/szski/wwv-mcp)** — reference MCP server. 15 tools. Required for any LLM-driven use of the bus.
- **[silvertakana/wwv-data-engine](https://github.com/silvertakana/wwv-data-engine)** — separate repo, supplies the read-only `engine_query` data that the MCP server's read tools wrap.
+2 -9
View File
@@ -1,6 +1,6 @@
{
"name": "worldwideview",
"version": "2.9.3",
"version": "2.9.2",
"private": true,
"type": "module",
"packageManager": "[email protected]",
@@ -18,7 +18,6 @@
"build": "next build --webpack",
"start": "next start",
"test": "vitest run",
"test:mutate": "stryker run",
"lint": "eslint .",
"db:reset": "npx prisma migrate reset --force",
"generate": "prisma generate"
@@ -56,8 +55,6 @@
"zustand": "^5.0.13"
},
"devDependencies": {
"@stryker-mutator/core": "^9.6.1",
"@stryker-mutator/vitest-runner": "^9.6.1",
"@testing-library/dom": "^10.4.1",
"@testing-library/react": "^16.3.2",
"@types/bcryptjs": "^3.0.0",
@@ -82,11 +79,7 @@
},
"pnpm": {
"overrides": {
"@spz-loader/core": "0.3.0",
"form-data@<2.5.4": "^2.5.5",
"form-data@>=3.0.0 <3.0.4": "^3.0.4",
"form-data@>=4.0.0 <4.0.4": "^4.0.5",
"fast-uri@<3.1.2": "^3.1.2"
"@spz-loader/core": "0.3.0"
},
"onlyBuiltDependencies": [
"@prisma/engines",
+940 -829
View File
File diff suppressed because it is too large. Load diff
-74
View File
@@ -1,74 +0,0 @@
services:
wwv:
image: ghcr.io/silvertakana/worldwideview:latest
ports:
- "3000:3000"
volumes:
- wwv-data:/app/data
- ./public/plugins-local:/app/public/plugins-local:ro
env_file:
- path: .env
required: false
environment:
- "AUTH_SECRET=${AUTH_SECRET:-default_secret_for_local_dev}"
- "WWV_DEMO_ADMIN_SECRET=${WWV_DEMO_ADMIN_SECRET:-}"
- "WWV_BRIDGE_TOKEN=${WWV_BRIDGE_TOKEN:-}"
- "DATABASE_URL=postgresql://postgres:postgres@db:5432/worldwideview?schema=public"
depends_on:
db:
condition: service_healthy
healthcheck:
test: ["CMD-SHELL", "wget --no-verbose --tries=1 --spider http://localhost:3000/api/health || exit 1"]
interval: 30s
timeout: 10s
retries: 3
start_period: 30s
restart: unless-stopped
db:
image: postgres:15-alpine
restart: unless-stopped
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: worldwideview
ports:
- "5432:5432"
volumes:
- postgres-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres -d worldwideview"]
interval: 5s
timeout: 5s
retries: 5
start_period: 60s
wwv-data-engine:
image: ghcr.io/silvertakana/wwv-data-engine:latest
ports:
- "5000:5000"
environment:
- PORT=5000
- REDIS_URL=redis://wwv-redis:6379
- SEEDERS_DIR=/app/seeders
- DB_PATH=/app/data/engine.db
depends_on:
wwv-redis:
condition: service_healthy
restart: unless-stopped
profiles:
- engine
wwv-redis:
image: redis:7-alpine
healthcheck:
test: ['CMD', 'redis-cli', 'ping']
interval: 5s
timeout: 3s
retries: 5
profiles:
- engine
volumes:
wwv-data:
postgres-data:
+1 -1
View File
@@ -21,7 +21,7 @@ try {
# Generate docker-compose.yml
Write-Host "[*] Downloading docker-compose.yml..."
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/silvertakana/worldwideview/main/self-host/docker-compose.yml" -OutFile docker-compose.yml
Invoke-WebRequest -Uri "https://raw.githubusercontent.com/silvertakana/worldwideview/main/docker-compose.yml" -OutFile docker-compose.yml
# Generate .env
if (-Not (Test-Path .env)) {
Regular → Executable
+1 -1
View File
@@ -19,7 +19,7 @@ fi
# 1. Download docker-compose.yml
echo "📦 Downloading docker-compose.yml..."
curl -fsSL -o docker-compose.yml https://raw.githubusercontent.com/silvertakana/worldwideview/main/self-host/docker-compose.yml
curl -fsSL -o docker-compose.yml https://raw.githubusercontent.com/silvertakana/worldwideview/main/docker-compose.yml
# 2. Generate .env with a persistent secret
if [ ! -f .env ]; then
-60
View File
@@ -1,60 +0,0 @@
import { NextResponse, type NextRequest } from "next/server";
import { auth } from "@/lib/auth";
import { agentBus, type AgentAction } from "@/lib/agent/bus";
/**
* POST /api/agent/publish
*
* Accept an AgentAction from a trusted caller (an external tool acting as
* the logged-in user) and broadcast it to every subscriber currently
* listening on /api/agent/stream *for the same user*. The browser subscriber
* routes the action onto the client-side dataBus, which the React + Cesium
* app already drives off of.
*
* Returns the number of clients the action reached.
*
* Auth: same session-cookie gate as /stream — only the same user's
* sessions can publish or subscribe, and per-user routing is enforced
* inside the bus.
*/
export async function POST(req: NextRequest) {
const session = await auth();
if (!session?.user?.id) {
return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
}
const userId = session.user.id;
let body: unknown;
try {
body = await req.json();
} catch {
return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
}
if (!isAgentAction(body)) {
return NextResponse.json(
{ error: "Body must be an AgentAction with a recognized `action` field" },
{ status: 400 },
);
}
const result = agentBus.publish(userId, body);
return NextResponse.json({
ok: true,
delivered: result.delivered,
subscribers: agentBus.subscribersFor(userId),
});
}
function isAgentAction(v: unknown): v is AgentAction {
if (!v || typeof v !== "object") return false;
const a = (v as { action?: unknown }).action;
return (
a === "fly_to" ||
a === "face_towards" ||
a === "layer_toggle" ||
a === "highlight_layer" ||
a === "select_entity" ||
a === "ping"
);
}
-69
View File
@@ -1,69 +0,0 @@
import { auth } from "@/lib/auth";
import { agentBus } from "@/lib/agent/bus";
/**
* GET /api/agent/stream
*
* Server-Sent Events channel that the browser subscribes to. Each connected
* client receives every action `/api/agent/publish` broadcasts *for the
* same authenticated user*. Multi-tenant safe: user A's stream never sees
* user B's publishes.
*
* Auth-gated via Auth.js session.
*/
export async function GET() {
const session = await auth();
if (!session?.user?.id) {
return new Response("Unauthorized", { status: 401 });
}
const userId = session.user.id;
let unsubscribe = () => {};
const id = `${userId}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
const stream = new ReadableStream<Uint8Array>({
start(controller) {
const encoder = new TextEncoder();
// Initial comment + retry hint so EventSource has something to ack
// immediately and reconnects fast if the connection drops.
controller.enqueue(encoder.encode(":connected\nretry: 3000\n\n"));
unsubscribe = agentBus.subscribe(userId, {
id,
write: (chunk) => controller.enqueue(encoder.encode(chunk)),
close: () => {
try { controller.close(); } catch { /* already closed */ }
},
});
// Heartbeat every 25s so intermediaries (Caddy, nginx, CDNs) don't
// tear down a "stalled" connection. SSE-aware proxies typically
// need a comment line every <30s to keep the channel alive.
const heartbeat = setInterval(() => {
try {
controller.enqueue(encoder.encode(`:hb ${Date.now()}\n\n`));
} catch {
clearInterval(heartbeat);
}
}, 25_000);
(controller as any)._cleanup = () => {
clearInterval(heartbeat);
unsubscribe();
};
},
cancel() {
unsubscribe();
},
});
return new Response(stream, {
headers: {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache, no-transform",
"Connection": "keep-alive",
"X-Accel-Buffering": "no",
},
});
}
-44
View File
@@ -1,44 +0,0 @@
import { NextResponse } from "next/server";
import fs from "node:fs";
import path from "node:path";
/**
* GET /api/build
*
* Lightweight build identification — lets you confirm exactly which build
* the running browser tab is talking to. Pair with the `[wwv build] ...`
* client-side console log so a refresh mismatch (browser holding stale
* chunks) becomes obvious instead of looking like a feature regression.
*
* Public — no secrets here, just a build stamp + a few public flags useful
* for diagnostics.
*/
function readMaybe(p: string): string | null {
try {
return fs.readFileSync(p, "utf-8").trim();
} catch {
return null;
}
}
const BUILD_ID =
process.env.NEXT_PUBLIC_WWV_BUILD_ID ??
readMaybe(path.join(process.cwd(), ".build-id")) ??
"dev";
const BUILD_AT =
process.env.NEXT_PUBLIC_WWV_BUILD_AT ??
readMaybe(path.join(process.cwd(), ".build-at")) ??
null;
export async function GET() {
return NextResponse.json({
build_id: BUILD_ID,
built_at: BUILD_AT,
public_flags: {
agent_bus_enabled:
process.env.NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED === "true",
edition: process.env.NEXT_PUBLIC_WWV_EDITION ?? null,
},
});
}
-128
View File
@@ -1,128 +0,0 @@
/**
* NCDOT (North Carolina DOT) adapter.
*
* NCDOT exposes its public traffic-cam API in two parts: a bulk endpoint
* that returns ~770 cameras with only `{ id, latitude, longitude }`, and a
* detail endpoint that returns one camera's full record (locationName,
* roadId, countyId, imageURL, status). To get usable data we fan out an
* N+1 fetch from the bulk list with bounded concurrency. First call lands
* in ~15s; the registry's per-adapter cache holds it for 24h after that.
*
* No key required. Image URLs are direct ~45KB JPEGs at 640x360.
*/
import type { CameraAdapter, CameraFeature } from "./types";
const BULK_URL = "https://eapps.ncdot.gov/services/traffic-prod/v1/cameras";
const DETAIL_URL = (id: number) =>
`https://eapps.ncdot.gov/services/traffic-prod/v1/cameras/${id}`;
const CONCURRENCY = 20;
interface BulkRecord {
id: number;
latitude: number;
longitude: number;
}
interface DetailRecord {
id: number;
locationName: string | null;
displayName: string | null;
mileMarker: number | null;
roadId: number;
countyId: number;
latitude: number;
longitude: number;
imageURL: string;
isDOTCamera: boolean;
status: string;
}
async function fetchDetail(id: number): Promise<DetailRecord | null> {
try {
const res = await fetch(DETAIL_URL(id), {
headers: { "User-Agent": "WorldWideView/1.0" },
});
if (!res.ok) return null;
if (res.status === 204) return null; // camera deleted/unavailable
const text = await res.text();
if (!text) return null;
return JSON.parse(text) as DetailRecord;
} catch {
return null;
}
}
/** Bounded-concurrency Promise.all. */
async function mapWithConcurrency<T, R>(
items: T[],
limit: number,
worker: (item: T) => Promise<R>,
): Promise<R[]> {
const results: R[] = new Array(items.length);
let next = 0;
async function run() {
while (next < items.length) {
const i = next++;
results[i] = await worker(items[i]);
}
}
await Promise.all(Array.from({ length: limit }, run));
return results;
}
function toFeature(d: DetailRecord): CameraFeature | null {
if (d.status && d.status !== "OK") return null;
if (!d.imageURL) return null;
if (typeof d.latitude !== "number" || typeof d.longitude !== "number") return null;
return {
type: "Feature",
geometry: { type: "Point", coordinates: [d.longitude, d.latitude] },
properties: {
id: `ncdot-${d.id}`,
source: "ncdot",
stream: d.imageURL,
streamType: "image",
hls: null,
name: d.displayName || d.locationName || `NCDOT camera ${d.id}`,
country: "United States",
region: "North Carolina",
city: "North Carolina",
location_description: d.locationName ?? "",
categories: ["traffic"],
extra: {
mileMarker: d.mileMarker,
roadId: d.roadId,
countyId: d.countyId,
ncdotStatus: d.status,
},
},
};
}
export const ncdotAdapter: CameraAdapter = {
id: "ncdot",
displayName: "NCDOT (North Carolina)",
region: "United States — North Carolina",
fetch: async () => {
const bulkRes = await fetch(BULK_URL, {
headers: { "User-Agent": "WorldWideView/1.0" },
});
if (!bulkRes.ok) throw new Error(`NCDOT bulk ${bulkRes.status}`);
const bulk = (await bulkRes.json()) as BulkRecord[];
if (!Array.isArray(bulk)) return [];
const details = await mapWithConcurrency(bulk, CONCURRENCY, (b) =>
fetchDetail(b.id),
);
const features: CameraFeature[] = [];
for (const d of details) {
if (!d) continue;
const f = toFeature(d);
if (f) features.push(f);
}
return features;
},
};
@@ -1,88 +0,0 @@
/**
* OpenStreetMap surveillance points (`man_made=surveillance`).
*
* Location-only — most OSM surveillance nodes don't have public stream URLs,
* but the geometry alone is useful as a "where do public/government cameras
* exist" overlay alongside the live DOT feeds.
*
* The query is bounded to a list of major metros (~30km radius each) so a
* single Overpass call doesn't return hundreds of thousands of points.
* Operators who want fuller coverage can extend `OVERPASS_QUERY` and bump
* the per-query cap. Output is capped at 3000 nodes total.
*
* Cache TTL is 7 days — OSM data changes slowly and Overpass is shared
* infrastructure that politely asks consumers not to re-poll aggressively.
*/
import type { CameraAdapter, CameraFeature } from "./types";
const OVERPASS_URL = "https://overpass-api.de/api/interpreter";
const OVERPASS_QUERY = `[out:json][timeout:25];
(
node["man_made"="surveillance"](around:30000,37.7749,-122.4194);
node["man_made"="surveillance"](around:30000,34.0522,-118.2437);
node["man_made"="surveillance"](around:30000,40.7128,-74.0060);
node["man_made"="surveillance"](around:30000,51.5074,-0.1278);
node["man_made"="surveillance"](around:30000,48.8566,2.3522);
node["man_made"="surveillance"](around:30000,35.6762,139.6503);
node["man_made"="surveillance"](around:30000,35.7796,-78.6382);
);
out body 3000;`;
interface OverpassNode {
type: "node";
id: number;
lat: number;
lon: number;
tags?: Record<string, string>;
}
export const osmSurveillanceAdapter: CameraAdapter = {
id: "osm-surveillance",
displayName: "OSM Surveillance Points",
region: "Global (sampled major metros)",
cacheTtlMs: 7 * 24 * 60 * 60 * 1000,
fetch: async () => {
const res = await fetch(OVERPASS_URL, {
method: "POST",
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"User-Agent": "WorldWideView/1.0",
},
body: `data=${encodeURIComponent(OVERPASS_QUERY)}`,
});
if (!res.ok) throw new Error(`overpass ${res.status}`);
const data = (await res.json()) as { elements?: OverpassNode[] };
const nodes = (data.elements ?? []).filter(
(e): e is OverpassNode =>
e.type === "node" && typeof e.lat === "number",
);
return nodes.map<CameraFeature>((n) => {
const t = n.tags ?? {};
return {
type: "Feature",
geometry: { type: "Point", coordinates: [n.lon, n.lat] },
properties: {
id: `osm-${n.id}`,
source: "osm-surveillance",
stream: null,
streamType: null,
hls: null,
name: t.name ?? "Surveillance",
country: t["addr:country"],
location_description: t.description ?? "",
categories: ["surveillance"],
extra: {
operator: t.operator,
surveillanceType: t["surveillance:type"],
cameraType: t["camera:type"],
cameraDirection: t.camera_direction,
osmId: n.id,
},
},
};
});
},
};
+2 -27
View File
@@ -4,8 +4,6 @@ import { gdotAdapter } from "./gdot";
import { tflAdapter } from "./tfl";
import { ny511Adapter } from "./ny511";
import { wsdotAdapter } from "./wsdot";
import { ncdotAdapter } from "./ncdot";
import { osmSurveillanceAdapter } from "./osm-surveillance";
/**
* All registered adapters. To add a new source, add an import + push the
@@ -19,8 +17,6 @@ export const ALL_ADAPTERS: CameraAdapter[] = [
tflAdapter,
ny511Adapter,
wsdotAdapter,
ncdotAdapter,
osmSurveillanceAdapter,
];
const ADAPTERS_BY_ID: Map<string, CameraAdapter> = new Map(
@@ -87,15 +83,6 @@ export function getAdapterMetadata(): CameraAdapterMeta[] {
* way, the cache entry's `error` field is set so `/api/camera/list` can
* report unhealthy adapters.
*/
/**
* Per-adapter cold-fetch timeout. If an upstream API hangs, the aggregator
* `Promise.allSettled` waits for the slowest one — so a single dead source
* holds up every other adapter's data from reaching the client. With this
* cap a stuck source becomes a fast error, and the cache fallback path
* keeps serving stale data without blocking the response.
*/
const ADAPTER_FETCH_TIMEOUT_MS = 4_000;
export async function fetchAdapter(adapter: CameraAdapter): Promise<CameraFeature[]> {
if (!isKeyAvailable(adapter)) {
return [];
@@ -103,23 +90,11 @@ export async function fetchAdapter(adapter: CameraAdapter): Promise<CameraFeatur
const now = Date.now();
const ttl = adapter.cacheTtlMs ?? DEFAULT_TTL_MS;
const c = cache.get(adapter.id);
// Serve from cache for the retry window even if the last attempt errored —
// otherwise every aggregated request re-fires a doomed upstream call and
// pays the timeout penalty each time. The error stays on the cache entry
// so /api/camera/list can still report the adapter as unhealthy.
if (c && now < c.expiry) {
if (c && now < c.expiry && !c.error) {
return c.data;
}
try {
const data = await Promise.race([
adapter.fetch(),
new Promise<CameraFeature[]>((_resolve, reject) =>
setTimeout(
() => reject(new Error(`Adapter ${adapter.id} timed out after ${ADAPTER_FETCH_TIMEOUT_MS}ms`)),
ADAPTER_FETCH_TIMEOUT_MS,
),
),
]);
const data = await adapter.fetch();
cache.set(adapter.id, {
data,
expiry: now + ttl,
+3 -10
View File
@@ -22,14 +22,7 @@
height: 48px;
margin: 0 auto 1rem;
border-radius: 0px;
/*
* Setup page is pre-auth and pre-theme — `--accent-rgb` defaults
* to `255, 255, 255` (white) in theme-tokens.css, which makes
* `rgb(255, 255, 255)` + `color: #fff` render invisible. Use an
* explicit brand color so the logo is visible before any theme
* applies.
*/
background: rgb(200, 30, 30);
background: rgb(var(--accent-rgb, 200, 30, 30));
color: #fff;
font-weight: 700;
font-size: 1.25rem;
@@ -78,7 +71,7 @@
}
.input:focus {
border-color: rgb(200, 30, 30);
border-color: rgb(var(--accent-rgb, 200, 30, 30));
}
.error {
@@ -90,7 +83,7 @@
.button {
margin-top: 0.75rem;
padding: 0.7rem;
background: rgb(200, 30, 30);
background: rgb(var(--accent-rgb, 200, 30, 30));
color: #fff;
border: none;
border-radius: 0px;
@@ -1,136 +0,0 @@
"use client";
/**
* Subscribes to the server's agent SSE channel and re-emits actions onto
* the client-side `dataBus`, so an external tool posting to
* /api/agent/publish lands on the same event surface the rest of the app
* already drives off of. Renders nothing — purely a side-effect component,
* paired with `DataBusSubscriber`.
*
* Disabled unless `NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED === "true"` so an
* unintended deployment doesn't open a remote-control channel for users
* who didn't opt in.
*/
import { useEffect } from "react";
import { dataBus } from "@/core/data/DataBus";
import { pluginManager } from "@/core/plugins/PluginManager";
interface FlyToMessage {
action: "fly_to";
lat: number;
lon: number;
alt?: number;
heading?: number;
distance?: number;
}
interface FaceTowardsMessage {
action: "face_towards";
lat: number;
lon: number;
alt?: number;
}
interface LayerToggleMessage {
action: "layer_toggle";
pluginId: string;
enabled: boolean;
}
interface HighlightMessage {
action: "highlight_layer";
pluginId: string;
}
interface SelectEntityMessage {
action: "select_entity";
pluginId: string;
entityId: string;
}
interface PingMessage {
action: "ping";
ts: number;
}
type AgentMessage =
| FlyToMessage
| FaceTowardsMessage
| LayerToggleMessage
| HighlightMessage
| SelectEntityMessage
| PingMessage;
function applyAction(msg: AgentMessage): void {
switch (msg.action) {
case "fly_to":
dataBus.emit("cameraGoTo", {
lat: msg.lat,
lon: msg.lon,
alt: msg.alt ?? 0,
distance: msg.distance,
heading: msg.heading,
});
return;
case "face_towards":
dataBus.emit("cameraFaceTowards", {
lat: msg.lat,
lon: msg.lon,
alt: msg.alt ?? 0,
});
return;
case "layer_toggle": {
const managed = pluginManager.getPlugin(msg.pluginId);
if (!managed) return;
if (managed.enabled === msg.enabled) return;
pluginManager.togglePlugin(msg.pluginId);
return;
}
case "highlight_layer":
dataBus.emit("layerToggled", { pluginId: msg.pluginId, enabled: true });
return;
case "select_entity": {
const entities = pluginManager.getEntities(msg.pluginId);
const entity = entities.find((e) => e.id === msg.entityId);
if (entity) dataBus.emit("entitySelected", { entity });
return;
}
case "ping":
// No-op — useful for an external tool to verify the channel is alive.
return;
}
}
export function AgentBusSubscriber() {
useEffect(() => {
// Log build-id + agent-bus state once on mount. A stale-bundle / config
// mismatch becomes visible at a glance in the browser console instead
// of looking like a feature regression.
const buildId = process.env.NEXT_PUBLIC_WWV_BUILD_ID ?? "dev";
const builtAt = process.env.NEXT_PUBLIC_WWV_BUILD_AT ?? "";
const agentBusEnabled =
process.env.NEXT_PUBLIC_WWV_AGENT_BUS_ENABLED === "true";
console.log(
`[wwv build] id=${buildId} built_at=${builtAt} agent_bus=${agentBusEnabled ? "on" : "off"}`,
);
if (!agentBusEnabled) return;
if (typeof EventSource === "undefined") return;
const es = new EventSource("/api/agent/stream", { withCredentials: true });
es.onmessage = (event) => {
try {
const msg = JSON.parse(event.data) as AgentMessage;
applyAction(msg);
} catch (err) {
console.warn("[AgentBus] malformed message", err);
}
};
es.onerror = (err) => {
// EventSource auto-reconnects on its own with the `retry:` value
// we send from the server. Just log; don't tear down.
console.debug("[AgentBus] stream error (auto-reconnecting)", err);
};
return () => {
es.close();
};
}, []);
return null;
}
-2
View File
@@ -28,7 +28,6 @@ import { useBootSequence } from "@/core/hooks/useBootSequence";
import { useIsMobile } from "@/core/hooks/useIsMobile";
import { useMarketplaceSync } from "@/core/hooks/useMarketplaceSync";
import { DataBusSubscriber } from "./DataBusSubscriber";
import { AgentBusSubscriber } from "./AgentBusSubscriber";
import { MobileHudBar } from "./MobileHudBar";
import { MobileCameraStats } from "./MobileCameraStats";
import dynamic from "next/dynamic";
@@ -178,7 +177,6 @@ export function AppShell() {
<TimelineSync />
<DataBusSubscriber />
<AgentBusSubscriber />
<Header />
{isMobile && <MobileHudBar />}
-95
View File
@@ -1,95 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { fetchLocalEngineManifest, localEngineHasPlugin, resetManifestCache } from "./engineManifest";
import { resolveEngineUrl } from "./resolveEngineUrl";
import { pluginManager } from "@/core/plugins/PluginManager";
// Mock PluginManager
vi.mock("@/core/plugins/PluginManager", () => ({
pluginManager: {
getPlugin: vi.fn(),
getManifest: vi.fn(),
},
}));
describe("EngineManifest", () => {
beforeEach(() => {
vi.clearAllMocks();
resetManifestCache();
global.fetch = vi.fn() as any;
});
it("should fetch manifest from local engine and cache it", async () => {
(global.fetch as any).mockResolvedValue({
ok: true,
json: async () => ({ plugins: ["plugin-a", "plugin-b"] }),
});
const plugins = await fetchLocalEngineManifest();
expect(plugins).toEqual(["plugin-a", "plugin-b"]);
expect(localEngineHasPlugin("plugin-a")).toBe(true);
expect(localEngineHasPlugin("plugin-c")).toBe(false);
// Second call should used cache
await fetchLocalEngineManifest();
expect(global.fetch).toHaveBeenCalledTimes(1);
});
it("should return null and cache failure if local engine is missing", async () => {
(global.fetch as any).mockRejectedValue(new Error("Connection refused"));
const plugins = await fetchLocalEngineManifest();
expect(plugins).toBeNull();
// Should not retry fetch
await fetchLocalEngineManifest();
expect(global.fetch).toHaveBeenCalledTimes(1);
});
});
describe("resolveEngineUrl", () => {
beforeEach(() => {
resetManifestCache();
vi.clearAllMocks();
});
it("should prioritize local engine if plugin is found there", async () => {
// Setup local manifest
(global.fetch as any).mockResolvedValue({
ok: true,
json: async () => ({ plugins: ["plugin-local"] }),
});
await fetchLocalEngineManifest();
const url = resolveEngineUrl("plugin-local");
expect(url).toContain("localhost:5000/stream");
});
it("should fall back to plugin's custom streamUrl if not local", () => {
(pluginManager.getPlugin as any).mockReturnValue({
plugin: {
getServerConfig: () => ({ streamUrl: "ws://custom-engine/stream" })
}
});
const url = resolveEngineUrl("plugin-custom");
expect(url).toBe("ws://custom-engine/stream");
});
it("should fall back to manifest streamUrl if provided", () => {
(pluginManager.getPlugin as any).mockReturnValue(undefined);
(pluginManager.getManifest as any).mockReturnValue({
dataSource: { streamUrl: "ws://manifest-engine/stream" }
});
const url = resolveEngineUrl("plugin-manifest");
expect(url).toBe("ws://manifest-engine/stream");
});
it("should use default cloud engine as last resort", () => {
(pluginManager.getPlugin as any).mockReturnValue(undefined);
(pluginManager.getManifest as any).mockReturnValue(undefined);
const url = resolveEngineUrl("unknown-plugin");
expect(url).toContain("worldwideview.dev/stream");
});
});
-172
View File
@@ -1,172 +0,0 @@
import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
import { wsClient } from "./WsClient";
import { dataBus } from "./DataBus";
import { pluginManager } from "../plugins/PluginManager";
// Mock DataBus
vi.mock("./DataBus", () => ({
dataBus: {
emit: vi.fn(),
},
}));
// Mock PluginManager
vi.mock("../plugins/PluginManager", () => ({
pluginManager: {
getPlugin: vi.fn(),
},
}));
// Mock Store
vi.mock("../state/store", () => ({
useStore: {
getState: vi.fn(() => ({
entitiesByPlugin: {},
setLayerLoading: vi.fn(),
})),
},
}));
describe("WsClient", () => {
let mockWs: any;
beforeEach(() => {
vi.useFakeTimers();
vi.clearAllMocks();
// Mock WebSocket global
mockWs = {
send: vi.fn(),
close: vi.fn(),
readyState: 0, // CONNECTING
};
global.WebSocket = vi.fn().mockImplementation(function() {
return mockWs;
}) as any;
Object.assign(global.WebSocket, {
CONNECTING: 0,
OPEN: 1,
CLOSING: 2,
CLOSED: 3,
});
// Clear singleton state
(wsClient as any).engines.clear();
});
afterEach(() => {
vi.useRealTimers();
});
it("should create a new WebSocket connection when subscribing to a new engine", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
expect(global.WebSocket).toHaveBeenCalledWith("ws://engine-1/stream");
});
it("should reuse an existing connection for the same engine URL", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
wsClient.subscribe("plugin-b", "ws://engine-1/stream");
expect(global.WebSocket).toHaveBeenCalledTimes(1);
});
it("should send a subscribe action once the socket is open", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
// Simulate open
mockWs.readyState = 1; // OPEN
mockWs.onopen();
expect(mockWs.send).toHaveBeenCalledWith(
JSON.stringify({ action: "subscribe", pluginId: "plugin-a" })
);
});
it("should attempt to reconnect after 5s if the connection is closed while subscriptions exist", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
mockWs.onclose();
expect(global.WebSocket).toHaveBeenCalledTimes(1); // Initial
vi.advanceTimersByTime(5000);
expect(global.WebSocket).toHaveBeenCalledTimes(2); // Reconnect
});
it("should close the connection after 30s if all plugins unsubscribe", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
wsClient.unsubscribe("plugin-a", "ws://engine-1/stream");
// Should not close immediately (grace period)
expect(mockWs.close).not.toHaveBeenCalled();
vi.advanceTimersByTime(30000);
expect(mockWs.close).toHaveBeenCalled();
});
it("should handle data messages and emit dataUpdated via DataBus", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
const mockEntities = [{ id: "1", type: "point", lat: 10, lng: 20 }];
const message = {
type: "data",
pluginId: "plugin-a",
payload: mockEntities
};
mockWs.onmessage({ data: JSON.stringify(message) });
expect(dataBus.emit).toHaveBeenCalledWith("dataUpdated", expect.objectContaining({
pluginId: "plugin-a",
entities: expect.arrayContaining([
expect.objectContaining({ id: "1" })
])
}));
});
it("should use plugin's custom mapWebsocketPayload if available", () => {
const mockPlugin = {
mapWebsocketPayload: vi.fn((payload) => payload.map((e: any) => ({ ...e, custom: true })))
};
(pluginManager.getPlugin as any).mockReturnValue({ plugin: mockPlugin });
wsClient.subscribe("plugin-custom", "ws://engine-1/stream");
const mockEntities = [{ id: "1" }];
const message = {
type: "data",
pluginId: "plugin-custom",
payload: mockEntities
};
mockWs.onmessage({ data: JSON.stringify(message) });
expect(mockPlugin.mapWebsocketPayload).toHaveBeenCalled();
expect(dataBus.emit).toHaveBeenCalledWith("dataUpdated", expect.objectContaining({
entities: [expect.objectContaining({ custom: true })]
}));
});
it("should cancel cleanup timer if a new subscription is added during grace period", () => {
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
wsClient.unsubscribe("plugin-a", "ws://engine-1/stream");
// Cleanup timer is running
wsClient.subscribe("plugin-b", "ws://engine-1/stream");
vi.advanceTimersByTime(30000);
expect(mockWs.close).not.toHaveBeenCalled();
});
it("should print connections to console", () => {
const groupSpy = vi.spyOn(console, "groupCollapsed").mockImplementation(() => {});
const tableSpy = vi.spyOn(console, "table").mockImplementation(() => {});
wsClient.subscribe("plugin-a", "ws://engine-1/stream");
wsClient.printConnections();
expect(groupSpy).toHaveBeenCalled();
expect(tableSpy).toHaveBeenCalled();
});
});
+2 -28
View File
@@ -5,35 +5,9 @@
let localManifest: string[] | null = null;
let manifestFetched = false;
/**
* Resolve the base URL of the local data engine.
*
* Priority:
* 1. `NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL` env var — if the operator
* pointed plugins at a specific engine URL (most common in
* self-host setups), use that. We strip any trailing `/stream`
* since the var is sometimes set to the WebSocket URL.
* 2. `localhost:5001` — matches the port wwv-data-engine's
* docker-compose.yaml binds. The previous default of 5000 was
* always wrong: the engine has listened on 5001 since the v2
* refactor. Port 5000 is also famously hijacked on macOS by the
* AirPlay Receiver, which would return 403 to any GET regardless
* of whether an engine was running, so it produced misleading
* "no local engine" results on every macOS dev machine.
*/
function getLocalEngineBase() {
const envUrl = process.env.NEXT_PUBLIC_WWV_PLUGIN_DATA_ENGINE_URL;
if (envUrl) {
// Strip a trailing `/stream` if present (the var is sometimes
// set to the WebSocket URL); also normalize ws[s]:// to http[s]://.
return envUrl
.replace(/\/stream\/?$/, "")
.replace(/^ws:\/\//, "http://")
.replace(/^wss:\/\//, "https://")
.replace(/\/+$/, "");
}
if (typeof window === "undefined") return "http://localhost:5001";
return `${window.location.protocol}//${window.location.hostname}:5001`;
if (typeof window === "undefined") return "http://localhost:5000";
return `${window.location.protocol}//${window.location.hostname}:5000`;
}
/**
-146
View File
@@ -1,146 +0,0 @@
import { describe, it, expect } from "vitest";
import { applyFilters } from "./filterEngine";
import type { GeoEntity, FilterDefinition, FilterValue } from "@/core/plugins/PluginTypes";
/**
* Helper to keep the fixture set small and on-spec. `GeoEntity` requires
* `latitude`, `longitude`, `timestamp`, and `properties`; everything
* else (label, altitude, heading, speed) is optional. We omit the
* optional fields except where a specific test exercises them.
*/
function entity(overrides: Partial<GeoEntity> & Pick<GeoEntity, "id" | "pluginId" | "properties">): GeoEntity {
return {
latitude: 0,
longitude: 0,
timestamp: new Date(0),
...overrides,
};
}
describe("applyFilters", () => {
it("returns the original array unchanged when no active filters are provided", () => {
const entities: GeoEntity[] = [
entity({ id: "1", pluginId: "test", properties: {} }),
entity({ id: "2", pluginId: "test", properties: {} }),
];
expect(applyFilters(entities, [], {})).toEqual(entities);
});
it("returns a subset (or equal) of the input when filtering by text", () => {
const entities: GeoEntity[] = [
entity({ id: "1", pluginId: "test", label: "alpha", properties: { name: "alpha" } }),
entity({ id: "2", pluginId: "test", label: "beta", properties: { name: "beta" } }),
entity({ id: "3", pluginId: "test", label: "gamma", properties: { name: "gamma" } }),
];
const definitions: FilterDefinition[] = [
{ id: "name", label: "Name", type: "text", propertyKey: "name" },
];
const activeFilters: Record<string, FilterValue> = {
name: { type: "text", value: "a" },
};
const result = applyFilters(entities, definitions, activeFilters);
expect(result.length).toBeLessThanOrEqual(entities.length);
for (const item of result) expect(entities).toContainEqual(item);
});
it("handles each filter type and the missing-definition / unknown-type fallbacks", () => {
const entities: GeoEntity[] = [
entity({
id: "1",
pluginId: "test",
label: "test1",
properties: { category: "A", speed: 50, active: true, invalidNum: "NaN" },
}),
entity({
id: "2",
pluginId: "test",
label: "test2",
properties: { category: "B", speed: 100, active: false, noProp: undefined },
}),
];
// 1. Missing definition — filter is silently ignored
expect(
applyFilters(entities, [], { missing: { type: "boolean", value: true } }),
).toEqual(entities);
// 2. Select filter
const selectDef: FilterDefinition = {
id: "cat",
label: "Category",
type: "select",
propertyKey: "category",
};
expect(applyFilters(entities, [selectDef], { cat: { type: "select", values: ["A"] } })).toEqual([
entities[0],
]);
expect(applyFilters(entities, [selectDef], { cat: { type: "select", values: [] } })).toEqual(
entities,
); // empty select == no filter
expect(applyFilters(entities, [selectDef], { cat: { type: "select", values: ["C"] } })).toEqual(
[],
);
// 3. Range filter — note: `range` is a NESTED config on FilterDefinition
const rangeDef: FilterDefinition = {
id: "spd",
label: "Speed",
type: "range",
propertyKey: "speed",
range: { min: 0, max: 200, step: 1 },
};
expect(applyFilters(entities, [rangeDef], { spd: { type: "range", min: 60, max: 150 } })).toEqual(
[entities[1]],
);
const invalidRangeDef: FilterDefinition = {
id: "inv",
label: "Invalid",
type: "range",
propertyKey: "invalidNum",
range: { min: 0, max: 200, step: 1 },
};
// entities[0] has invalidNum: "NaN" → fails; entities[1] has it undefined → 0 → matches
expect(
applyFilters(entities, [invalidRangeDef], { inv: { type: "range", min: 0, max: 100 } }),
).toEqual([entities[1]]);
// 4. Boolean filter
const boolDef: FilterDefinition = {
id: "act",
label: "Active",
type: "boolean",
propertyKey: "active",
};
expect(applyFilters(entities, [boolDef], { act: { type: "boolean", value: false } })).toEqual([
entities[1],
]);
// 5. Unknown filter type — falls through unchanged
const unknownDef: FilterDefinition = {
id: "unk",
label: "Unknown",
type: "unknown" as unknown as FilterDefinition["type"],
propertyKey: "active",
};
expect(
applyFilters(entities, [unknownDef], {
unk: { type: "unknown" as unknown as FilterValue["type"] } as unknown as FilterValue,
}),
).toEqual(entities);
// 6. Text filter with empty value — no filtering
const textDef: FilterDefinition = {
id: "txt",
label: "Text",
type: "text",
propertyKey: "label",
};
expect(applyFilters(entities, [textDef], { txt: { type: "text", value: "" } })).toEqual(
entities,
);
});
});
+5 -11
View File
@@ -1,7 +1,7 @@
import { Cartesian3, Color, Ellipsoid } from "cesium";
import type { Viewer as CesiumViewer } from "cesium";
import { useStore } from "@/core/state/store";
import { createLabel, removeLabel, getCollections, type AnimatableItem } from "./EntityRenderer";
import { createLabel, removeLabel, type AnimatableItem } from "./EntityRenderer";
import { tickStackAnimation } from "./stackAnimation";
import { updateModelTransform } from "./ModelManager";
import { isAnyStackExpanded, isEntityInExpandedStack, getEntityTargetPosition, isEntityClustered, getStackStateVersion } from "./StackManager";
@@ -11,13 +11,6 @@ import {
applyHighlight,
} from "./animationHelpers";
declare global {
interface Window {
/** Animation-loop frame counter. Exposed for external plugin throttling. */
_wwvFrameCount?: number;
}
}
const R_WGS84_MIN = 6356752.0;
const R2 = R_WGS84_MIN * R_WGS84_MIN;
@@ -114,13 +107,14 @@ export function createUpdateLoop(
}
const animatables = animatablesRef.current;
const { labels: labelsCollection, billboards } = getCollections(viewer);
const labelsCollection = (viewer as any)._wwvLabels;
// Always run stack animation tick so that ghost hubs can be cleaned up
// even if the user toggles all layers off!
const billboards = (viewer as any)._wwvBillboards;
let isAnimatingStack = false;
if (billboards) {
isAnimatingStack = tickStackAnimation(labelsCollection ?? null, billboards);
isAnimatingStack = tickStackAnimation(labelsCollection, billboards);
}
if (animatables.length === 0) {
@@ -134,7 +128,7 @@ export function createUpdateLoop(
const Dh = Math.sqrt(camDistSqr - R2);
const frame = frameCount++;
window._wwvFrameCount = frame;
(window as any)._wwvFrameCount = frame; // Expose globally for throttling
const isStaticCullFrame = frame % STATIC_HORIZON_INTERVAL === 0;
const selectedId = state.selectedEntity?.id ?? null;
const hoveredId = hoveredEntityIdRef.current;
-164
View File
@@ -1,164 +0,0 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
// jsdom doesn't provide matchMedia; renderSingleEntity uses it for default point size.
Object.defineProperty(window, 'matchMedia', {
writable: true,
value: vi.fn().mockImplementation((query: string) => ({
matches: false,
media: query,
onchange: null,
addListener: vi.fn(),
removeListener: vi.fn(),
addEventListener: vi.fn(),
removeEventListener: vi.fn(),
dispatchEvent: vi.fn(),
})),
});
vi.mock('cesium', () => {
class FakeCollection {
blendOption = 0;
add = vi.fn((x: unknown) => x);
remove = vi.fn();
constructor(_?: unknown) {}
}
return {
PointPrimitiveCollection: FakeCollection,
BillboardCollection: FakeCollection,
LabelCollection: FakeCollection,
PolylineCollection: FakeCollection,
Color: { BLACK: { _kind: 'BLACK' }, WHITE: { _kind: 'WHITE' } },
Cartesian3: { fromDegrees: vi.fn() },
Cartographic: { fromCartesian: vi.fn(() => ({ height: 1000 })) },
Ellipsoid: { WGS84: {} },
VerticalOrigin: { BOTTOM: 0 },
DistanceDisplayCondition: class { constructor(_n: number, _f: number) {} },
NearFarScalar: class { constructor(_a: number, _b: number, _c: number, _d: number) {} },
HeightReference: { CLAMP_TO_GROUND: 0 },
};
});
vi.mock('./primitiveOps', () => ({
updateExistingItem: vi.fn(),
createNewItem: vi.fn(),
cleanupRemovedEntities: vi.fn(),
getDefaultDotIcon: vi.fn(() => 'data:svg,auto-icon'),
}));
vi.mock('./renderCaches', () => ({
scratchPosition: {},
getEntityColor: vi.fn(() => ({ _kind: 'color' })),
getCachedColor: vi.fn(() => null),
markAnimatablesDirty: vi.fn(),
getStableAnimatables: vi.fn(() => []),
}));
vi.mock('./ChunkedProcessor', () => ({
globalChunkedProcessor: {
cancel: vi.fn(),
processChunked: vi.fn(),
},
}));
vi.mock('./StackManager', () => ({
rebuildStacks: vi.fn(),
calculateGridSizeDegrees: vi.fn(() => 1),
}));
import { initPrimitiveCollections, getCollections, renderEntities } from './EntityRenderer';
import * as primitiveOps from './primitiveOps';
function createViewer() {
return {
scene: {
primitives: { add: vi.fn((x: unknown) => x) },
requestRender: vi.fn(),
},
camera: {
positionWC: {},
positionCartographic: { height: 1000 },
},
isDestroyed: () => false,
};
}
describe('EntityRenderer — primitive collections (WeakMap roundtrip)', () => {
it('returns empty shape before init', () => {
const v = createViewer();
expect(getCollections(v as never)).toEqual({});
});
it('populates all four collections after init', () => {
const v = createViewer();
initPrimitiveCollections(v as never);
const c = getCollections(v as never);
expect(c.points).toBeDefined();
expect(c.billboards).toBeDefined();
expect(c.labels).toBeDefined();
expect(c.polylines).toBeDefined();
expect(v.scene.primitives.add).toHaveBeenCalledTimes(4);
});
it('isolates collections per viewer (WeakMap independence)', () => {
const a = createViewer();
const b = createViewer();
initPrimitiveCollections(a as never);
expect(getCollections(a as never).points).toBeDefined();
expect(getCollections(b as never)).toEqual({});
});
it('does not throw when viewer has no scene', () => {
const broken = { scene: null } as never;
expect(() => initPrimitiveCollections(broken)).not.toThrow();
expect(getCollections(broken)).toEqual({});
});
});
describe('EntityRenderer — defer-clone in renderSingleEntity (P1)', () => {
const createNewItem = vi.mocked(primitiveOps.createNewItem);
beforeEach(() => {
createNewItem.mockClear();
});
it('passes options through by reference when iconUrl is already set', () => {
const v = createViewer();
initPrimitiveCollections(v as never);
const options = { iconUrl: 'icon.png', type: 'billboard' };
const entity = { id: 'e1', longitude: 0, latitude: 0, altitude: 0, properties: {} };
renderEntities(v as never, [{ entity: entity as never, options: options as never }], new Map());
expect(createNewItem).toHaveBeenCalledTimes(1);
const passedOptions = createNewItem.mock.calls[0][1];
expect(passedOptions).toBe(options); // no clone
});
it('clones options when the auto-SVG branch fires; original is not mutated', () => {
const v = createViewer();
initPrimitiveCollections(v as never);
const options = { color: '#abc' }; // no iconUrl, type !== "model"
const entity = { id: 'e2', longitude: 0, latitude: 0, altitude: 0, properties: {} };
renderEntities(v as never, [{ entity: entity as never, options: options as never }], new Map());
const passedOptions = createNewItem.mock.calls[0][1] as unknown as Record<string, unknown>;
expect(passedOptions).not.toBe(options);
expect(passedOptions.iconUrl).toBe('data:svg,auto-icon');
expect(passedOptions.iconScale).toBe(1.0);
expect(passedOptions._isAutoSVG).toBe(true);
expect((options as unknown as Record<string, unknown>).iconUrl).toBeUndefined();
});
it('does not clone for type === "model" entities', () => {
const v = createViewer();
initPrimitiveCollections(v as never);
const options = { type: 'model', modelUrl: 'plane.glb' };
const entity = { id: 'e3', longitude: 0, latitude: 0, altitude: 0, properties: {} };
renderEntities(v as never, [{ entity: entity as never, options: options as never }], new Map());
const passedOptions = createNewItem.mock.calls[0][1];
expect(passedOptions).toBe(options); // no clone
});
});
+19 -35
View File
@@ -40,15 +40,6 @@ export interface AnimatableItem {
/** Global render kickstarter for deeply nested async operations. */
export let globalRequestRender: () => void = () => { };
export interface PrimitiveCollections {
points: PointPrimitiveCollection;
billboards: BillboardCollection;
labels: LabelCollection;
polylines: PolylineCollection;
}
const collectionsByViewer = new WeakMap<CesiumViewer, PrimitiveCollections>();
/** Initialize primitive collections on the viewer. */
export function initPrimitiveCollections(viewer: CesiumViewer): void {
if (!viewer?.scene?.primitives) {
@@ -57,19 +48,12 @@ export function initPrimitiveCollections(viewer: CesiumViewer): void {
}
const points = new PointPrimitiveCollection();
points.blendOption = 2; // TRANSLUCENT
viewer.scene.primitives.add(points);
(viewer as any)._wwvPoints = viewer.scene.primitives.add(points);
const billboards = new BillboardCollection({ scene: viewer.scene });
billboards.blendOption = 2; // TRANSLUCENT
viewer.scene.primitives.add(billboards);
const labels = new LabelCollection({ scene: viewer.scene });
viewer.scene.primitives.add(labels);
const polylines = new PolylineCollection();
viewer.scene.primitives.add(polylines);
collectionsByViewer.set(viewer, { points, billboards, labels, polylines });
(viewer as any)._wwvBillboards = viewer.scene.primitives.add(billboards);
(viewer as any)._wwvLabels = viewer.scene.primitives.add(new LabelCollection({ scene: viewer.scene }));
(viewer as any)._wwvPolylines = viewer.scene.primitives.add(new PolylineCollection());
globalRequestRender = () => {
if (viewer && !viewer.isDestroyed()) {
@@ -78,9 +62,14 @@ export function initPrimitiveCollections(viewer: CesiumViewer): void {
};
}
/** Get the primitive collections for a viewer. Returns an empty shape if init hasn't run. */
export function getCollections(viewer: CesiumViewer): Partial<PrimitiveCollections> {
return collectionsByViewer.get(viewer) ?? {};
/** Get typed references to the primitive collections. */
export function getCollections(viewer: CesiumViewer) {
return {
points: (viewer as any)._wwvPoints as PointPrimitiveCollection,
billboards: (viewer as any)._wwvBillboards as BillboardCollection,
labels: (viewer as any)._wwvLabels as LabelCollection,
polylines: (viewer as any)._wwvPolylines as PolylineCollection,
};
}
/** Creates a label primitive for an item (lazy evaluation). */
@@ -120,21 +109,16 @@ function renderSingleEntity(
) {
currentIds.add(entity.id);
Cartesian3.fromDegrees(entity.longitude, entity.latitude, entity.altitude || 0, Ellipsoid.WGS84, scratchPosition);
const baseColor = getEntityColor(options);
// Auto-upgrade missing icons to SVG Billboards so pixelOffsets (spiderifier) will work.
// Only clone when the auto-SVG branch actually mutates — otherwise pass `options` through.
let effectiveOptions: CesiumEntityOptions = options;
if (!options.iconUrl && options.type !== "model") {
// Auto-upgrade missing icons to SVG Billboards so pixelOffsets (spiderifier) will work
const effectiveOptions = { ...options };
const baseColor = getEntityColor(effectiveOptions);
if (!effectiveOptions.iconUrl && effectiveOptions.type !== "model") {
const baseOutlineColor = getCachedColor(options.outlineColor) || Color.BLACK;
const outWidth = options.outlineWidth || 1;
const pSize = options.size || (typeof window !== "undefined" && window.matchMedia("(pointer: coarse)").matches ? 12 : 8);
effectiveOptions = {
...options,
iconUrl: getDefaultDotIcon(baseColor, baseOutlineColor, outWidth, pSize),
iconScale: 1.0,
};
effectiveOptions.iconUrl = getDefaultDotIcon(baseColor, baseOutlineColor, outWidth, pSize);
effectiveOptions.iconScale = 1.0;
(effectiveOptions as any)._isAutoSVG = true;
}
@@ -1,109 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
// Mock cesium before importing the module under test
vi.mock("cesium", () => {
class UrlTemplateImageryProvider {
_type = "UrlTemplate";
url: string;
subdomains?: string[];
constructor(opts: any) { this.url = opts.url; this.subdomains = opts.subdomains; }
}
const BingMapsImageryProvider = {
fromUrl: vi.fn().mockResolvedValue({ _type: "Bing" }),
};
const IonImageryProvider = {
fromAssetId: vi.fn().mockResolvedValue({ _type: "Ion" }),
};
const ArcGisMapServerImageryProvider = {
fromUrl: vi.fn().mockResolvedValue({ _type: "ArcGis" }),
};
return {
IonImageryProvider,
BingMapsImageryProvider,
ArcGisMapServerImageryProvider,
UrlTemplateImageryProvider,
BingMapsStyle: { AERIAL: "Aerial", AERIAL_WITH_LABELS: "AerialWithLabels", ROAD: "Road" },
};
});
import { IonImageryProvider } from "cesium";
import { createImageryProvider, createOsmProvider } from "./ImageryProviderFactory";
beforeEach(() => {
vi.clearAllMocks();
delete process.env.NEXT_PUBLIC_BING_MAPS_KEY;
});
describe("createOsmProvider", () => {
it("returns a UrlTemplateImageryProvider for OSM tiles", () => {
const provider = createOsmProvider();
expect(provider).toBeDefined();
expect((provider as any).url).toContain("openstreetmap.org");
});
});
describe("createImageryProvider", () => {
it("returns Google tiles for bing-aerial when no Bing key (first tier)", async () => {
const provider = await createImageryProvider("bing-aerial");
expect((provider as any).url).toContain("google.com");
expect((provider as any).url).toContain("lyrs=s");
expect(IonImageryProvider.fromAssetId).not.toHaveBeenCalled();
});
it("returns Google tiles for bing-labels when no Bing key (hybrid)", async () => {
const provider = await createImageryProvider("bing-labels");
expect((provider as any).url).toContain("google.com");
expect((provider as any).url).toContain("lyrs=y");
});
it("returns Google tiles for bing-road when no Bing key (roads)", async () => {
const provider = await createImageryProvider("bing-road");
expect((provider as any).url).toContain("google.com");
expect((provider as any).url).toContain("lyrs=m");
});
it("returns Google tiles for blue-marble when no keys", async () => {
const provider = await createImageryProvider("blue-marble");
expect((provider as any).url).toContain("google.com");
});
it("falls back to Ion when Google provider throws", async () => {
const { UrlTemplateImageryProvider } = await import("cesium");
const origImpl = UrlTemplateImageryProvider;
// Make UrlTemplateImageryProvider throw only for google URLs
// We need to test the fallback path - simulate by making IonImageryProvider
// the expected path when Google fails
vi.mocked(IonImageryProvider.fromAssetId).mockResolvedValue({ _type: "Ion" } as any);
// Since UrlTemplateImageryProvider is a constructor and won't normally throw,
// the Google tier will succeed. Test Ion fallback via useImageryManager catch instead.
// Here we verify Ion is called when it's the path taken.
const provider = await createImageryProvider("bing-aerial");
// Google succeeds first, so Ion should NOT be called
expect(IonImageryProvider.fromAssetId).not.toHaveBeenCalled();
expect((provider as any).url).toContain("google.com");
});
it("uses Bing directly when NEXT_PUBLIC_BING_MAPS_KEY is set", async () => {
process.env.NEXT_PUBLIC_BING_MAPS_KEY = "test-bing-key";
const { BingMapsImageryProvider } = await import("cesium");
const provider = await createImageryProvider("bing-aerial");
expect(BingMapsImageryProvider.fromUrl).toHaveBeenCalled();
expect((provider as any)._type).toBe("Bing");
});
it("returns OSM for 'osm' layer directly", async () => {
const provider = await createImageryProvider("osm");
expect((provider as any).url).toContain("openstreetmap.org");
});
it("returns OSM for unknown layer ids", async () => {
const provider = await createImageryProvider("nonexistent-layer");
expect((provider as any).url).toContain("openstreetmap.org");
});
});
+13 -39
View File
@@ -1,6 +1,7 @@
import {
BingMapsImageryProvider,
IonImageryProvider,
OpenStreetMapImageryProvider,
ArcGisMapServerImageryProvider,
UrlTemplateImageryProvider,
BingMapsStyle,
@@ -59,39 +60,6 @@ export const IMAGERY_LAYERS: ImageryLayerEntry[] = [
}
];
export function createOsmProvider() {
return new UrlTemplateImageryProvider({
url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
subdomains: ["a", "b", "c"]
});
}
function createGoogleProvider(lyrs: string) {
return new UrlTemplateImageryProvider({
url: `https://mt{s}.google.com/vt/lyrs=${lyrs}&x={x}&y={y}&z={z}`,
subdomains: ["0", "1", "2", "3"]
});
}
async function tieredFallback(ionAssetId: number, googleLyrs: string) {
// 1. Try Google XYZ tiles
try {
return createGoogleProvider(googleLyrs);
} catch (googleErr) {
console.warn("[ImageryProvider] Google tiles failed, trying Bing via Ion:", googleErr);
}
// 2. Try Bing via Cesium Ion (free shared token)
try {
return await IonImageryProvider.fromAssetId(ionAssetId);
} catch (ionErr) {
console.warn("[ImageryProvider] Ion/Bing failed, falling back to OSM:", ionErr);
}
// 3. OSM as last resort
return createOsmProvider();
}
export async function createImageryProvider(layerId: string) {
const bingKey = process.env.NEXT_PUBLIC_BING_MAPS_KEY;
@@ -103,7 +71,7 @@ export async function createImageryProvider(layerId: string) {
mapStyle: BingMapsStyle.AERIAL,
});
}
return await tieredFallback(2, "s");
return await IonImageryProvider.fromAssetId(2);
case "bing-labels":
if (bingKey) {
@@ -112,7 +80,7 @@ export async function createImageryProvider(layerId: string) {
mapStyle: BingMapsStyle.AERIAL_WITH_LABELS,
});
}
return await tieredFallback(3, "y");
return await IonImageryProvider.fromAssetId(3);
case "bing-road":
if (bingKey) {
@@ -121,10 +89,13 @@ export async function createImageryProvider(layerId: string) {
mapStyle: BingMapsStyle.ROAD,
});
}
return await tieredFallback(4, "m");
return await IonImageryProvider.fromAssetId(4);
case "osm":
return createOsmProvider();
return new UrlTemplateImageryProvider({
url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
subdomains: ["a", "b", "c"]
});
case "arcgis-world":
return await ArcGisMapServerImageryProvider.fromUrl(
@@ -132,9 +103,12 @@ export async function createImageryProvider(layerId: string) {
);
case "blue-marble":
return await tieredFallback(3845, "s");
return await IonImageryProvider.fromAssetId(3845);
default:
return createOsmProvider();
return new UrlTemplateImageryProvider({
url: "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png",
subdomains: ["a", "b", "c"]
});
}
}
+2 -2
View File
@@ -2,7 +2,7 @@ import { useEffect, useRef } from "react";
import type { Viewer as CesiumViewer } from "cesium";
import { Cartographic, Cartesian3 } from "cesium";
import type { GeoEntity, CesiumEntityOptions } from "@/core/plugins/PluginTypes";
import { renderEntities, renderEntitiesChunked, AnimatableItem, getCollections } from "../EntityRenderer";
import { renderEntities, renderEntitiesChunked, AnimatableItem } from "../EntityRenderer";
import { createUpdateLoop } from "../AnimationLoop";
import { rebuildStacks, calculateGridSizeDegrees } from "../StackManager";
@@ -146,7 +146,7 @@ export function useEntityRendering(
viewer.clock.onTick.removeEventListener(updatePositions);
viewer.scene.preUpdate.removeEventListener(handlePreUpdateClustering);
// Synchronously flush all labels to prevent stale labels persisting
const { labels } = getCollections(viewer);
const labels = (viewer as any)?._wwvLabels;
if (labels) {
for (const item of animatablesMapRef.current.values()) {
if (item.labelPrimitive && !item.labelPrimitive.isDestroyed?.()) {
+1 -11
View File
@@ -6,7 +6,7 @@ import {
Cesium3DTileset
} from "cesium";
import { useStore } from "@/core/state/store";
import { createImageryProvider, createOsmProvider } from "./ImageryProviderFactory";
import { createImageryProvider } from "./ImageryProviderFactory";
export function useImageryManager(viewer: CesiumViewer | null, viewerReady: boolean) {
const baseLayerId = useStore((s) => s.mapConfig.baseLayerId);
@@ -90,16 +90,6 @@ export function useImageryManager(viewer: CesiumViewer | null, viewerReady: bool
currentImageryLayerRef.current = newLayer;
} catch (err) {
console.error("[useImageryManager] Failed to load imagery:", activeLayerId, err);
try {
const osmProvider = createOsmProvider();
const osmLayer = new ImageryLayer(osmProvider);
if (viewer.isDestroyed()) return;
viewer.imageryLayers.add(osmLayer, 0);
currentImageryLayerRef.current = osmLayer;
console.warn("[useImageryManager] Loaded OSM as fallback imagery");
} catch (fallbackErr) {
console.error("[useImageryManager] OSM fallback also failed:", fallbackErr);
}
}
}
}
-300
View File
@@ -1,300 +0,0 @@
import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
/**
* PluginManager is the orchestrator everything else routes through —
* register, enable, disable, fetch coordination, cache + bus updates.
* Bugs here have wide blast radius: pins disappear, layers never load,
* the agent bus stops driving the UI.
*
* Testing philosophy: we let the real `dataBus`, `cacheLayer`, and
* `pollingManager` through (each is covered by its own unit tests) so
* these tests verify the *observable* interaction between PluginManager
* and the data layer — events fired, cache entries written, plugins
* shown as enabled in the public API. Tests pin contracts that
* downstream refactors should preserve, not implementation details
* that should be allowed to change.
*
* Mocked: the Zustand store, analytics, engine-URL resolution, the
* local-engine manifest fetcher, and the manifest loader. None are
* load-bearing for these assertions; they otherwise drag in Cesium or
* heavy framework setup.
*/
vi.mock("@/core/state/store", () => ({
useStore: {
getState: () => ({
setLayerLoading: () => {},
dataConfig: { pluginSettings: {}, pollingIntervals: {} },
isPlaybackMode: false,
currentTime: new Date(),
showErrorToast: undefined,
}),
subscribe: () => () => {},
},
}));
vi.mock("@/lib/analytics", () => ({ trackEvent: () => {} }));
vi.mock("@/core/data/resolveEngineUrl", () => ({
resolveEngineUrl: () => "wss://test.example/stream",
}));
vi.mock("@/core/data/engineManifest", () => ({
fetchLocalEngineManifest: async () => null,
}));
vi.mock("./loadPluginFromManifest", () => ({
loadPluginFromManifest: vi.fn(),
}));
import { pluginManager } from "./PluginManager";
import { dataBus } from "@/core/data/DataBus";
import { cacheLayer } from "@/core/data/CacheLayer";
import { loadPluginFromManifest } from "./loadPluginFromManifest";
import type { GeoEntity, WorldPlugin } from "@/core/plugins/PluginTypes";
function makePlugin(overrides: Partial<WorldPlugin> = {}): WorldPlugin {
return {
id: "test-plugin",
name: "Test Plugin",
description: "for tests",
icon: "Box",
category: "custom",
version: "1.0.0",
initialize: async () => {},
destroy: () => {},
fetch: async () => [],
getPollingInterval: () => 0,
getLayerConfig: () => ({
color: "#fff",
clusterEnabled: false,
clusterDistance: 50,
}),
renderEntity: () => ({ type: "point" }),
...overrides,
};
}
function makeEntity(id: string, pluginId: string): GeoEntity {
return {
id,
pluginId,
latitude: 0,
longitude: 0,
timestamp: new Date(),
properties: {},
};
}
beforeEach(() => {
cacheLayer.clear();
});
afterEach(() => {
// PluginManager doesn't expose a registry-clear; destroy() runs the
// teardown the AppShell uses at unmount.
pluginManager.destroy();
dataBus.removeAllListeners();
vi.clearAllMocks();
});
describe("PluginManager.registerPlugin", () => {
it("stores the plugin and emits pluginRegistered with the default interval", async () => {
const handler = vi.fn();
dataBus.on("pluginRegistered", handler);
const plugin = makePlugin({ id: "reg-1", getPollingInterval: () => 30_000 });
await pluginManager.registerPlugin(plugin);
expect(pluginManager.getPlugin("reg-1")).toBeDefined();
expect(handler).toHaveBeenCalledWith({
pluginId: "reg-1",
defaultInterval: 30_000,
});
});
it("ignores a second registerPlugin with the same id and warns", async () => {
const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
await pluginManager.registerPlugin(makePlugin({ id: "dup", name: "first" }));
await pluginManager.registerPlugin(makePlugin({ id: "dup", name: "second" }));
expect(pluginManager.getPlugin("dup")?.plugin.name).toBe("first");
expect(warnSpy).toHaveBeenCalled();
warnSpy.mockRestore();
});
});
describe("PluginManager.enablePlugin", () => {
it("flips enabled=true and emits layerToggled(true)", async () => {
const layerHandler = vi.fn();
dataBus.on("layerToggled", layerHandler);
await pluginManager.registerPlugin(makePlugin({ id: "en-1" }));
await pluginManager.enablePlugin("en-1");
expect(pluginManager.getPlugin("en-1")?.enabled).toBe(true);
expect(layerHandler).toHaveBeenCalledWith({ pluginId: "en-1", enabled: true });
});
it("emits a fresh dataUpdated from cache before kicking off polling", async () => {
const dataHandler = vi.fn();
const cachedEntities = [makeEntity("e1", "en-2")];
cacheLayer.set("en-2", cachedEntities, 60_000);
await pluginManager.registerPlugin(makePlugin({ id: "en-2" }));
dataBus.on("dataUpdated", dataHandler);
await pluginManager.enablePlugin("en-2");
expect(dataHandler).toHaveBeenCalledWith({
pluginId: "en-2",
entities: cachedEntities,
});
});
});
describe("PluginManager.disablePlugin", () => {
it("clears entities and emits layerToggled(false) + dataUpdated([])", async () => {
const layerHandler = vi.fn();
const dataHandler = vi.fn();
await pluginManager.registerPlugin(makePlugin({ id: "dis-1" }));
await pluginManager.enablePlugin("dis-1");
dataBus.on("layerToggled", layerHandler);
dataBus.on("dataUpdated", dataHandler);
pluginManager.disablePlugin("dis-1");
expect(pluginManager.getPlugin("dis-1")?.enabled).toBe(false);
expect(pluginManager.getEntities("dis-1")).toEqual([]);
expect(layerHandler).toHaveBeenCalledWith({ pluginId: "dis-1", enabled: false });
expect(dataHandler).toHaveBeenCalledWith({ pluginId: "dis-1", entities: [] });
});
});
describe("PluginManager — data flow contract", () => {
it("a plugin's onDataUpdate writes through to the cache and emits dataUpdated", async () => {
const dataHandler = vi.fn();
dataBus.on("dataUpdated", dataHandler);
await pluginManager.registerPlugin(makePlugin({ id: "df-1" }));
const managed = pluginManager.getPlugin("df-1");
const entities = [makeEntity("a", "df-1"), makeEntity("b", "df-1")];
managed!.context.onDataUpdate(entities);
// Cache populated for the plugin id
expect(cacheLayer.get("df-1")).toEqual(entities);
// Bus emits with the same entities
expect(dataHandler).toHaveBeenCalledWith({
pluginId: "df-1",
entities,
});
// Public accessor reflects the update
expect(pluginManager.getEntities("df-1")).toEqual(entities);
});
});
describe("PluginManager — getAllEntities filters by enabled flag", () => {
it("excludes entities owned by a disabled plugin", async () => {
await pluginManager.registerPlugin(makePlugin({ id: "ae-on" }));
await pluginManager.registerPlugin(makePlugin({ id: "ae-off" }));
await pluginManager.enablePlugin("ae-on");
// ae-off intentionally not enabled
// Both plugins receive data updates...
pluginManager.getPlugin("ae-on")!.context.onDataUpdate([
makeEntity("on-1", "ae-on"),
]);
pluginManager.getPlugin("ae-off")!.context.onDataUpdate([
makeEntity("off-1", "ae-off"),
]);
// ...but getAllEntities only returns entities from enabled plugins.
const all = pluginManager.getAllEntities();
expect(all.map((e) => e.id)).toEqual(["on-1"]);
});
});
describe("PluginManager.updateTimeRange", () => {
it("calls plugin.fetch on every enabled plugin with the new range", async () => {
const fetchSpy = vi.fn(async () => []);
await pluginManager.registerPlugin(
makePlugin({ id: "tr-on", fetch: fetchSpy }),
);
await pluginManager.registerPlugin(
makePlugin({ id: "tr-off", fetch: vi.fn(async () => []) }),
);
await pluginManager.enablePlugin("tr-on");
// tr-off stays disabled
const timeRange = {
start: new Date("2026-01-01"),
end: new Date("2026-01-02"),
};
await pluginManager.updateTimeRange(timeRange);
// Enabled plugin's fetch was called with the new range
expect(fetchSpy).toHaveBeenCalledWith(timeRange);
// Disabled plugin's fetch was NOT called
const disabledPluginFetch = pluginManager.getPlugin("tr-off")!.plugin.fetch as ReturnType<typeof vi.fn>;
expect(disabledPluginFetch).not.toHaveBeenCalled();
});
});
describe("PluginManager.destroy", () => {
it("calls plugin.destroy on each registered plugin and clears the registry", async () => {
const destroySpy1 = vi.fn();
const destroySpy2 = vi.fn();
await pluginManager.registerPlugin(
makePlugin({ id: "d-1", destroy: destroySpy1 }),
);
await pluginManager.registerPlugin(
makePlugin({ id: "d-2", destroy: destroySpy2 }),
);
pluginManager.destroy();
expect(destroySpy1).toHaveBeenCalled();
expect(destroySpy2).toHaveBeenCalled();
expect(pluginManager.getAllPlugins()).toEqual([]);
});
});
describe("PluginManager.togglePlugin", () => {
it("flips a plugin between enabled and disabled across successive calls", async () => {
await pluginManager.registerPlugin(makePlugin({ id: "tg-1" }));
expect(pluginManager.getPlugin("tg-1")?.enabled).toBe(false);
// togglePlugin is sync but calls async enablePlugin; wait for
// the state flip to land.
pluginManager.togglePlugin("tg-1");
await vi.waitFor(() =>
expect(pluginManager.getPlugin("tg-1")?.enabled).toBe(true),
);
// Second toggle should flip it off — disablePlugin is sync, so
// no waitFor needed.
pluginManager.togglePlugin("tg-1");
expect(pluginManager.getPlugin("tg-1")?.enabled).toBe(false);
});
});
describe("PluginManager.loadFromManifest", () => {
it("delegates to loadPluginFromManifest and registers the result", async () => {
const fakePlugin = makePlugin({ id: "lm-1", name: "From Manifest" });
(loadPluginFromManifest as ReturnType<typeof vi.fn>).mockResolvedValue(
fakePlugin,
);
await pluginManager.loadFromManifest({
id: "lm-1",
name: "From Manifest",
version: "1.0.0",
type: "data-layer",
format: "bundle",
trust: "built-in",
capabilities: ["data:own"],
category: "custom",
icon: "Box",
entry: "/dev/null",
} as never);
expect(loadPluginFromManifest).toHaveBeenCalled();
expect(pluginManager.getPlugin("lm-1")).toBeDefined();
expect(pluginManager.getPlugin("lm-1")?.plugin.name).toBe("From Manifest");
});
});
@@ -1,39 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { loadPluginFromManifest, ManifestLoadError } from "./loadPluginFromManifest";
import { validateManifest } from "./validateManifest";
vi.mock("./validateManifest", () => ({
validateManifest: vi.fn(),
}));
describe("loadPluginFromManifest", () => {
beforeEach(() => {
vi.clearAllMocks();
});
it("should throw ManifestLoadError if validation fails", async () => {
(validateManifest as any).mockReturnValue({
valid: false,
errors: ["Missing ID"],
});
const manifest: any = { id: "test" };
await expect(loadPluginFromManifest(manifest)).rejects.toThrow(ManifestLoadError);
await expect(loadPluginFromManifest(manifest)).rejects.toThrow("Invalid manifest: Missing ID");
});
it("should attempt to load bundle if manifest is valid", async () => {
(validateManifest as any).mockReturnValue({ valid: true, errors: [] });
// We can't easily mock the dynamic import of an arbitrary string in this environment
// without complex setup, so we expect it to fail with a specific error from the catch block
const manifest: any = { id: "test", entry: "http://invalid-path.js" };
await expect(loadPluginFromManifest(manifest)).rejects.toThrow(ManifestLoadError);
await expect(loadPluginFromManifest(manifest)).rejects.toThrow("Failed to load plugin");
});
// Note: Testing the actual instantiation logic of loadBundlePlugin
// requires a real ESM module or a more sophisticated mock for the import() call.
// Given the constraints, we have verified the high-level orchestration.
});
@@ -204,156 +204,4 @@ describe("DeclarativePlugin", () => {
expect(opts.color).toBe("#ff0000");
expect(opts.labelText).toBe("Test");
});
test("destroy clears context", async () => {
const plugin = new DeclarativePlugin(makeManifest());
await plugin.initialize({} as any);
// We can't strictly observe context, but we can verify it doesn't throw
expect(() => plugin.destroy()).not.toThrow();
});
test("fetch uses query auth if specified", async () => {
vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({ features: [] }),
}));
const originalEnv = process.env;
process.env = { ...originalEnv, API_KEY: "secret123" };
const plugin = new DeclarativePlugin(makeManifest({
dataSource: {
url: "https://api.example.com/data?type=test",
method: "GET",
pollInterval: 60000,
format: "geojson",
auth: { type: "query", key: "token", envVar: "API_KEY" }
}
}));
await plugin.fetch({ start: new Date(), end: new Date() });
expect(fetch).toHaveBeenCalledWith(
"https://api.example.com/data?type=test&token=secret123",
expect.any(Object)
);
process.env = originalEnv;
});
test("fetch does not use query auth if envVar is missing", async () => {
vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({ features: [] }),
}));
const originalEnv = process.env;
process.env = { ...originalEnv };
delete process.env.MISSING_KEY;
const plugin = new DeclarativePlugin(makeManifest({
dataSource: {
url: "https://api.example.com/data",
method: "GET",
pollInterval: 60000,
format: "geojson",
auth: { type: "query", key: "token", envVar: "MISSING_KEY" }
}
}));
await plugin.fetch({ start: new Date(), end: new Date() });
expect(fetch).toHaveBeenCalledWith(
"https://api.example.com/data",
expect.any(Object)
);
process.env = originalEnv;
});
test("fetch uses header auth if specified", async () => {
vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({ features: [] }),
}));
const originalEnv = process.env;
process.env = { ...originalEnv, HEADER_KEY: "bearer 123" };
const plugin = new DeclarativePlugin(makeManifest({
dataSource: {
url: "https://api.example.com/data",
method: "GET",
pollInterval: 60000,
format: "geojson",
auth: { type: "header", key: "Authorization", envVar: "HEADER_KEY" }
}
}));
await plugin.fetch({ start: new Date(), end: new Date() });
expect(fetch).toHaveBeenCalledWith(
"https://api.example.com/data",
expect.objectContaining({
headers: expect.objectContaining({
"Authorization": "bearer 123"
})
})
);
process.env = originalEnv;
});
test("fetch handles request body", async () => {
vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({ features: [] }),
}));
const plugin = new DeclarativePlugin(makeManifest({
dataSource: {
url: "https://api.example.com/data",
method: "POST",
pollInterval: 60000,
format: "geojson",
body: { query: "test" }
}
}));
await plugin.fetch({ start: new Date(), end: new Date() });
expect(fetch).toHaveBeenCalledWith(
"https://api.example.com/data",
expect.objectContaining({
method: "POST",
body: JSON.stringify({ query: "test" })
})
);
});
test("fetch returns empty if mapping is missing", async () => {
vi.stubGlobal("fetch", vi.fn().mockResolvedValue({
ok: true,
json: () => Promise.resolve({ features: [] }),
}));
const plugin = new DeclarativePlugin(makeManifest({
fieldMapping: undefined
}));
const result = await plugin.fetch({ start: new Date(), end: new Date() });
expect(result).toEqual([]);
});
test("renderEntity returns billboard correctly", () => {
const plugin = new DeclarativePlugin(makeManifest({
rendering: {
entityType: "billboard",
icon: "/icon.png"
}
}));
const opts = plugin.renderEntity({} as any);
expect(opts.type).toBe("billboard");
expect(opts.iconUrl).toBe("/icon.png");
});
});
@@ -1,5 +1,4 @@
import { describe, test, expect } from "vitest";
import fc from "fast-check";
import { getNestedValue } from "./getNestedValue";
describe("getNestedValue", () => {
@@ -46,49 +45,4 @@ describe("getNestedValue", () => {
const obj = { properties: { mag: "5.2" } };
expect(getNestedValue(obj, "properties.mag")).toBe("5.2");
});
describe("Property-based testing", () => {
test("never throws an exception regardless of object structure or path", () => {
fc.assert(
fc.property(
fc.object(),
fc.string(),
(obj, path) => {
// The core property: getNestedValue should be safe and never throw
// It should either return a value or undefined
try {
getNestedValue(obj, path);
return true;
} catch (e) {
return false; // Should never reach here
}
}
),
{ numRuns: 1000 }
);
});
test("always returns undefined for empty path if object is truthy", () => {
fc.assert(
fc.property(
fc.object(),
(obj) => {
expect(getNestedValue(obj, "")).toBeUndefined();
}
)
);
});
test("always returns undefined when object is null or undefined", () => {
fc.assert(
fc.property(
fc.string(),
(path) => {
expect(getNestedValue(null, path)).toBeUndefined();
expect(getNestedValue(undefined, path)).toBeUndefined();
}
)
);
});
});
});
@@ -1,116 +0,0 @@
import { describe, test, expect } from "vitest";
import { mapGeoJsonToEntities } from "./mapGeoJsonToEntities";
describe("mapGeoJsonToEntities", () => {
test("handles valid geojson with full mapping", () => {
const data = {
features: [
{
id: "feat-1",
geometry: { type: "Point", coordinates: [174, -36, 10] },
properties: { speed: 100, heading: 90, time: "2026-05-14T00:00:00Z", label: "Test" }
}
]
};
const entities = mapGeoJsonToEntities(data, {
id: "id",
latitude: "geometry.coordinates[1]",
longitude: "geometry.coordinates[0]",
altitude: "geometry.coordinates[2]",
speed: "properties.speed",
heading: "properties.heading",
timestamp: "properties.time",
label: "properties.label",
properties: { custom: "properties.speed" }
}, "plugin1");
expect(entities).toHaveLength(1);
expect(entities[0].altitude).toBe(10);
expect(entities[0].speed).toBe(100);
expect(entities[0].heading).toBe(90);
expect(entities[0].timestamp.toISOString()).toBe("2026-05-14T00:00:00.000Z");
expect(entities[0].properties.custom).toBe(100);
});
test("handles missing properties definition", () => {
const data = {
features: [
{
geometry: { type: "Point", coordinates: [174, -36] },
properties: {}
}
]
};
const entities = mapGeoJsonToEntities(data, {
id: "id",
latitude: "geometry.coordinates[1]",
longitude: "geometry.coordinates[0]",
}, "plugin1");
expect(entities).toHaveLength(1);
expect(entities[0].properties).toEqual({});
expect(entities[0].id).toBe("plugin1-0"); // fallback to index
});
test("handles asNumber edge cases (null, non-finite)", () => {
const data = {
features: [
{
id: "feat-2",
geometry: { type: "Point", coordinates: [174, -36] },
properties: { speed: null, heading: "NaN", alt: "Infinity" }
}
]
};
const entities = mapGeoJsonToEntities(data, {
id: "id",
latitude: "geometry.coordinates[1]",
longitude: "geometry.coordinates[0]",
speed: "properties.speed",
heading: "properties.heading",
altitude: "properties.alt"
}, "plugin1");
expect(entities).toHaveLength(1);
expect(entities[0].speed).toBeUndefined(); // null -> undefined
expect(entities[0].heading).toBeUndefined(); // NaN -> undefined
expect(entities[0].altitude).toBeUndefined(); // Infinity -> undefined
});
test("handles parseTimestamp edge cases (invalid string, fallback)", () => {
const data = {
features: [
{
geometry: { type: "Point", coordinates: [174, -36] },
properties: { time1: "invalid-date", time2: null }
}
]
};
const entities = mapGeoJsonToEntities(data, {
id: "id",
latitude: "geometry.coordinates[1]",
longitude: "geometry.coordinates[0]",
timestamp: "properties.time1"
}, "plugin1");
expect(entities).toHaveLength(1);
// Invalid string falls back to current date, we just check it's a valid date
expect(entities[0].timestamp).toBeInstanceOf(Date);
expect(isNaN(entities[0].timestamp.getTime())).toBe(false);
const entities2 = mapGeoJsonToEntities(data, {
id: "id",
latitude: "geometry.coordinates[1]",
longitude: "geometry.coordinates[0]",
timestamp: "properties.time2"
}, "plugin1");
expect(entities2).toHaveLength(1);
expect(entities2[0].timestamp).toBeInstanceOf(Date);
expect(isNaN(entities2[0].timestamp.getTime())).toBe(false);
});
});
@@ -1,72 +0,0 @@
import { describe, test, expect } from "vitest";
import { mapJsonToEntities } from "./mapJsonToEntities";
describe("mapJsonToEntities", () => {
test("handles arrayPath resolution", () => {
const data = {
wrapper: {
items: [
{ id: 1, lat: 10, lon: 20 }
]
}
};
const entities = mapJsonToEntities(data, {
id: "id",
latitude: "lat",
longitude: "lon"
}, "plugin1", "wrapper.items");
expect(entities).toHaveLength(1);
expect(entities[0].id).toBe("plugin1-1");
});
test("handles non-array resolution gracefully", () => {
const data = { wrapper: { items: "not-an-array" } };
const entities = mapJsonToEntities(data, {
id: "id",
latitude: "lat",
longitude: "lon"
}, "plugin1", "wrapper.items");
expect(entities).toEqual([]);
});
test("handles asNumber and parseTimestamp edge cases", () => {
const data = [
{ id: 1, lat: 10, lon: 20, speed: null, alt: "Infinity", time: "invalid-date" }
];
const entities = mapJsonToEntities(data, {
id: "id",
latitude: "lat",
longitude: "lon",
speed: "speed",
altitude: "alt",
timestamp: "time"
}, "plugin1");
expect(entities).toHaveLength(1);
expect(entities[0].speed).toBeUndefined();
expect(entities[0].altitude).toBeUndefined();
expect(entities[0].timestamp).toBeInstanceOf(Date);
expect(isNaN(entities[0].timestamp.getTime())).toBe(false);
});
test("skips items missing lat or lon", () => {
const data = [
{ id: 1, lat: 10 }, // missing lon
{ id: 2, lon: 20 }, // missing lat
{ id: 3, lat: null, lon: 20 }
];
const entities = mapJsonToEntities(data, {
id: "id",
latitude: "lat",
longitude: "lon"
}, "plugin1");
expect(entities).toEqual([]);
});
});
-48
View File
@@ -1,48 +0,0 @@
import { describe, it, expect } from "vitest";
import { validateManifest } from "./validateManifest";
describe("validateManifest", () => {
it("should validate a correct manifest", () => {
const manifest: any = {
id: "test-plugin",
name: "Test Plugin",
version: "1.0.0",
type: "data-layer",
trust: "verified",
capabilities: ["streaming"],
entry: "/plugins/test.js"
};
const result = validateManifest(manifest);
expect(result.valid).toBe(true);
expect(result.errors).toHaveLength(0);
});
it("should flag missing required fields", () => {
const result = validateManifest({});
expect(result.valid).toBe(false);
expect(result.errors).toContain("Missing required field: id");
expect(result.errors).toContain("Missing required field: name");
expect(result.errors).toContain("Missing required field: version");
expect(result.errors).toContain("Missing required field: entry");
});
it("should flag invalid entry URLs", () => {
const manifest: any = {
id: "p1", name: "n1", version: "1", type: "data-layer", trust: "verified",
capabilities: ["c1"], entry: "https://hacker.com/malicious.js"
};
const result = validateManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors).toContain("entry URL must be a relative path, CDN, localhost, or worldwideview.dev domain");
});
it("should require extends for extensions", () => {
const manifest: any = {
id: "p1", name: "n1", version: "1", type: "extension", trust: "verified",
capabilities: ["c1"], entry: "/p.js"
};
const result = validateManifest(manifest);
expect(result.valid).toBe(false);
expect(result.errors).toContain("Extension plugins require a non-empty extends array");
});
});
-167
View File
@@ -1,167 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { createGlobeSlice } from "./globeSlice";
import { createLayersSlice } from "./layersSlice";
import { createUISlice } from "./uiSlice";
import { createDataSlice } from "./dataSlice";
import { createConfigSlice } from "./configSlice";
import { createFavoritesSlice } from "./favoritesSlice";
import { createTimelineSlice } from "./timelineSlice";
import { createFilterSlice } from "./filterSlice";
describe("State Slices", () => {
describe("GlobeSlice", () => {
it("should set camera position", () => {
let state: any = {};
const set = (update: any) => { state = { ...state, ...update }; };
const slice = createGlobeSlice(set, () => ({} as any), {} as any);
slice.setCameraPosition(10, 20, 30);
expect(state.cameraLat).toBe(10);
expect(state.cameraLon).toBe(20);
expect(state.cameraAlt).toBe(30);
});
});
describe("LayersSlice", () => {
it("should toggle layer", () => {
let state: any = { layers: { "p1": { enabled: false } } };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createLayersSlice(set, () => state as any, {} as any);
slice.toggleLayer("p1");
expect(state.layers["p1"].enabled).toBe(true);
});
it("should init layer if missing", () => {
let state: any = { layers: {} };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createLayersSlice(set, () => state as any, {} as any);
slice.initLayer("p2", true);
expect(state.layers["p2"]).toEqual({ enabled: true, entityCount: 0, loading: false });
});
});
describe("UISlice", () => {
beforeEach(() => {
vi.stubGlobal("localStorage", {
getItem: vi.fn(),
setItem: vi.fn(),
});
vi.stubGlobal("document", {
documentElement: {
setAttribute: vi.fn(),
},
});
});
it("should toggle theme", () => {
let state: any = { theme: "black" };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createUISlice(set, () => state as any, {} as any);
slice.toggleTheme();
expect(state.theme).toBe("light");
expect(document.documentElement.setAttribute).toHaveBeenCalledWith("data-theme", "light");
});
it("should add floating stream", () => {
let state: any = { floatingStreams: [] };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createUISlice(set, () => state as any, {} as any);
slice.addFloatingStream({ id: "s1", label: "Stream 1", streamUrl: "url", isIframe: false });
expect(state.floatingStreams.length).toBe(1);
expect(state.floatingStreams[0].id).toBe("s1");
});
});
describe("DataSlice", () => {
it("should set entities and keep selectedEntity fresh", () => {
let state: any = {
entitiesByPlugin: {},
selectedEntity: { id: "1", pluginId: "p1", name: "Old Name" }
};
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const get = () => state;
const slice = createDataSlice(set, get, {} as any);
const newEntities = [{ id: "1", pluginId: "p1", name: "New Name" } as any];
slice.setEntities("p1", newEntities);
expect(state.entitiesByPlugin["p1"]).toEqual(newEntities);
expect(state.selectedEntity.name).toBe("New Name");
});
});
describe("ConfigSlice", () => {
it("should update data config", () => {
let state: any = { dataConfig: { cacheEnabled: false } };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createConfigSlice(set, () => ({} as any), {} as any);
slice.updateDataConfig({ cacheEnabled: true });
expect(state.dataConfig.cacheEnabled).toBe(true);
});
it("should set polling interval", () => {
let state: any = { dataConfig: { pollingIntervals: {} } };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createConfigSlice(set, () => ({} as any), {} as any);
slice.setPollingInterval("p1", 5000);
expect(state.dataConfig.pollingIntervals["p1"]).toBe(5000);
});
});
describe("FavoritesSlice", () => {
beforeEach(() => {
global.fetch = vi.fn().mockResolvedValue({ ok: true }) as any;
vi.stubGlobal("document", { cookie: "" });
});
it("should add favorite and trigger sync", () => {
let state: any = { favorites: [] };
const set = (update: any) => { state = { ...state, ...update }; };
const slice = createFavoritesSlice(set, () => state as any, {} as any);
const entity = { id: "e1", pluginId: "p1", label: "Entity 1" };
slice.addFavorite(entity as any, "Plugin 1");
expect(state.favorites.length).toBe(1);
expect(state.favorites[0].id).toBe("e1");
expect(global.fetch).toHaveBeenCalledWith("/api/user/favorites", expect.any(Object));
});
it("should sync to cookies in demo mode", () => {
// requires mocking isDemo to true
});
});
describe("TimelineSlice", () => {
it("should set time window and calculate range", () => {
let state: any = { timeWindow: "1h", timeRange: null };
const set = (update: any) => { state = { ...state, ...update }; };
const slice = createTimelineSlice(set, () => ({} as any), {} as any);
slice.setTimeWindow("6h");
expect(state.timeWindow).toBe("6h");
expect(state.timeRange.start).toBeInstanceOf(Date);
expect(state.timeRange.end).toBeInstanceOf(Date);
});
});
describe("FilterSlice", () => {
it("should set and clear filters", () => {
let state: any = { filters: {} };
const set = (fn: any) => { state = { ...state, ...fn(state) }; };
const slice = createFilterSlice(set, () => ({} as any), {} as any);
slice.setFilter("p1", "f1", { type: "boolean", value: true });
expect(state.filters["p1"]["f1"]).toEqual({ type: "boolean", value: true });
slice.clearFilters("p1");
expect(state.filters["p1"]).toBeUndefined();
});
});
});
-70
View File
@@ -1,70 +0,0 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createConfigSlice, ConfigSlice } from './configSlice';
describe('configSlice', () => {
let store: StoreApi<ConfigSlice>;
beforeEach(() => {
// Mock localStorage
vi.stubGlobal('localStorage', {
getItem: vi.fn(),
setItem: vi.fn(),
clear: vi.fn(),
});
store = createStore<ConfigSlice>((set, get, api) => createConfigSlice(set as any, get as any, api as any));
});
it('initializes with default config', () => {
const state = store.getState();
expect(state.dataConfig.cacheEnabled).toBe(true);
expect(state.mapConfig.antiAliasing).toBe('fxaa');
});
it('updates data config', () => {
store.getState().updateDataConfig({ cacheEnabled: false, maxConcurrentRequests: 10 });
const state = store.getState();
expect(state.dataConfig.cacheEnabled).toBe(false);
expect(state.dataConfig.maxConcurrentRequests).toBe(10);
// Ensure other properties are untouched
expect(state.dataConfig.cacheMaxAge).toBe(3600000);
});
it('updates map config and syncs baseLayerId to localStorage', () => {
store.getState().updateMapConfig({ showFps: true, baseLayerId: 'satellite' });
const state = store.getState();
expect(state.mapConfig.showFps).toBe(true);
expect(state.mapConfig.baseLayerId).toBe('satellite');
// Ensure localStorage was called
expect(localStorage.setItem).toHaveBeenCalledWith('wwv_map_layer', 'satellite');
});
it('updates map config without baseLayerId does not touch localStorage', () => {
store.getState().updateMapConfig({ showFps: true });
expect(localStorage.setItem).not.toHaveBeenCalled();
});
it('sets polling interval for a plugin', () => {
store.getState().setPollingInterval('plugin-a', 5000);
const state = store.getState();
expect(state.dataConfig.pollingIntervals['plugin-a']).toBe(5000);
});
it('updates plugin settings deeply', () => {
// Initial set
store.getState().updatePluginSettings('plugin-a', { param1: 'value1' });
expect(store.getState().dataConfig.pluginSettings['plugin-a']).toEqual({ param1: 'value1' });
// Update set (should merge)
store.getState().updatePluginSettings('plugin-a', { param2: 'value2' });
expect(store.getState().dataConfig.pluginSettings['plugin-a']).toEqual({
param1: 'value1',
param2: 'value2'
});
});
});
-83
View File
@@ -1,83 +0,0 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createDataSlice, DataSlice } from './dataSlice';
import type { GeoEntity } from '@/core/plugins/PluginTypes';
// We need a mock store that includes selectedEntity to test the cross-slice update behavior
interface MockAppStore extends DataSlice {
selectedEntity: GeoEntity | null;
}
describe('dataSlice', () => {
let store: StoreApi<MockAppStore>;
beforeEach(() => {
store = createStore<MockAppStore>((set, get, api) => {
const dataSlice = createDataSlice(set as any, get as any, api as any);
return {
...dataSlice,
selectedEntity: null,
};
});
});
it('initializes with empty entities', () => {
expect(store.getState().entitiesByPlugin).toEqual({});
});
it('sets entities for a plugin', () => {
const mockEntities = [{ id: 'e1', pluginId: 'plugin-a' } as GeoEntity];
store.getState().setEntities('plugin-a', mockEntities);
expect(store.getState().entitiesByPlugin['plugin-a']).toEqual(mockEntities);
});
it('updates selectedEntity if new data for the same entity arrives', () => {
// Initial selected entity
const oldEntity = { id: 'e1', pluginId: 'plugin-a', name: 'Old Name' } as any as GeoEntity;
store.setState({ selectedEntity: oldEntity });
// New data arrives with updated name
const freshEntity = { id: 'e1', pluginId: 'plugin-a', name: 'New Name' } as any as GeoEntity;
store.getState().setEntities('plugin-a', [freshEntity]);
expect(store.getState().selectedEntity).toEqual(freshEntity);
});
it('does not update selectedEntity if new data does not contain it', () => {
const oldEntity = { id: 'e1', pluginId: 'plugin-a', name: 'Old Name' } as any as GeoEntity;
store.setState({ selectedEntity: oldEntity });
// New data arrives but the entity is missing
store.getState().setEntities('plugin-a', [{ id: 'e2', pluginId: 'plugin-a' } as GeoEntity]);
expect(store.getState().selectedEntity).toEqual(oldEntity);
});
it('clears entities for a specific plugin', () => {
const mockEntitiesA = [{ id: 'e1', pluginId: 'plugin-a' } as GeoEntity];
const mockEntitiesB = [{ id: 'e2', pluginId: 'plugin-b' } as GeoEntity];
store.getState().setEntities('plugin-a', mockEntitiesA);
store.getState().setEntities('plugin-b', mockEntitiesB);
store.getState().clearEntities('plugin-a');
expect(store.getState().entitiesByPlugin['plugin-a']).toBeUndefined();
expect(store.getState().entitiesByPlugin['plugin-b']).toEqual(mockEntitiesB);
});
it('gets all entities across plugins flattened', () => {
const mockEntitiesA = [{ id: 'e1', pluginId: 'plugin-a' } as GeoEntity];
const mockEntitiesB = [{ id: 'e2', pluginId: 'plugin-b' } as GeoEntity];
store.getState().setEntities('plugin-a', mockEntitiesA);
store.getState().setEntities('plugin-b', mockEntitiesB);
const all = store.getState().getAllEntities();
expect(all).toHaveLength(2);
expect(all).toContainEqual(mockEntitiesA[0]);
expect(all).toContainEqual(mockEntitiesB[0]);
});
});
-106
View File
@@ -1,106 +0,0 @@
import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createFavoritesSlice, FavoritesSlice, FavoriteItem } from './favoritesSlice';
import type { GeoEntity } from '@/core/plugins/PluginTypes';
// Mock the edition module so we can control `isDemo`
vi.mock('@/core/edition', () => ({
isDemo: true // We'll override this in specific tests using vi.mocked if needed, but for now we default to true to test cookie logic
}));
import { isDemo } from '@/core/edition';
describe('favoritesSlice', () => {
let store: StoreApi<FavoritesSlice>;
beforeEach(() => {
// Reset document.cookie and mock fetch
Object.defineProperty(document, 'cookie', {
writable: true,
value: '',
});
vi.stubGlobal('fetch', vi.fn().mockResolvedValue({}));
store = createStore<FavoritesSlice>((set, get, api) => createFavoritesSlice(set as any, get as any, api as any));
});
afterEach(() => {
vi.restoreAllMocks();
});
const mockEntity = { id: 'entity-1', pluginId: 'plugin-a', label: 'Test Entity' } as GeoEntity;
it('initializes with empty favorites', () => {
expect(store.getState().favorites).toEqual([]);
});
it('initializes favorites from a provided array', () => {
const initialFavs: FavoriteItem[] = [{ id: 'fav-1', pluginId: 'p-1', label: 'L1', pluginName: 'PN1', lastSeen: 100 }];
store.getState().initFavorites(initialFavs);
expect(store.getState().favorites).toEqual(initialFavs);
});
it('adds a new favorite, sets lastSeen, and syncs cookie in demo mode', () => {
const now = 1000000;
vi.useFakeTimers();
vi.setSystemTime(now);
store.getState().addFavorite(mockEntity, 'Plugin A', 'icon-stub');
const favs = store.getState().favorites;
expect(favs).toHaveLength(1);
expect(favs[0]).toEqual(expect.objectContaining({
id: 'entity-1',
pluginId: 'plugin-a',
label: 'Test Entity',
pluginName: 'Plugin A',
icon: 'icon-stub',
lastSeen: now
}));
// Check cookie
expect(document.cookie).toContain('wwv_favorites');
vi.useRealTimers();
});
it('prevents adding duplicate favorites by id', () => {
store.getState().addFavorite(mockEntity, 'Plugin A');
store.getState().addFavorite(mockEntity, 'Plugin A'); // Should be ignored
expect(store.getState().favorites).toHaveLength(1);
});
it('removes a favorite and syncs cookie in demo mode', () => {
store.getState().addFavorite(mockEntity, 'Plugin A');
expect(store.getState().favorites).toHaveLength(1);
store.getState().removeFavorite('entity-1');
expect(store.getState().favorites).toHaveLength(0);
// Check cookie serialization updates
const decodedCookie = decodeURIComponent(document.cookie.replace('wwv_favorites=', ''));
expect(decodedCookie).toContain('[]'); // empty array after removal
});
describe('cloud mode (isDemo = false)', () => {
beforeEach(() => {
// Because isDemo is a constant exported from a module, standard vi.mock overriding per-test
// for constants is tricky without resetModules.
// We'll test the API logic by overriding it internally or just acknowledging we'd need to mock the import dynamically.
// For simplicity in this suite without full dynamic import mocking, we'll verify the fetch behavior
// by overriding the constant property if possible, or using a separate module mock.
});
// Note: To properly test fetch vs cookie branches, we'd typically inject `isDemo`
// or test it in an isolated test file. Since we defaulted to `isDemo: true`,
// fetch should NOT be called. Let's verify that.
it('does not call fetch API when in demo mode', () => {
store.getState().addFavorite(mockEntity, 'Plugin A');
expect(fetch).not.toHaveBeenCalled();
store.getState().removeFavorite('entity-1');
expect(fetch).not.toHaveBeenCalled();
});
});
});
-67
View File
@@ -1,67 +0,0 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createFilterSlice, FilterSlice } from './filterSlice';
import type { FilterValue } from '@/core/plugins/PluginTypes';
describe('filterSlice', () => {
let store: StoreApi<FilterSlice>;
beforeEach(() => {
store = createStore<FilterSlice>((set, get, api) => createFilterSlice(set as any, get as any, api as any));
});
it('initializes with empty filters', () => {
const state = store.getState();
expect(state.filters).toEqual({});
});
it('sets a specific filter for a plugin', () => {
const filterVal: FilterValue = { type: 'boolean', value: true };
store.getState().setFilter('plugin-a', 'show-active', filterVal);
const state = store.getState();
expect(state.filters['plugin-a']).toBeDefined();
expect(state.filters['plugin-a']['show-active']).toEqual(filterVal);
});
it('updates an existing filter without overwriting other filters for the same plugin', () => {
const filterVal1: FilterValue = { type: 'boolean', value: true };
const filterVal2: FilterValue = { type: 'select', values: ['option1'] };
store.getState().setFilter('plugin-a', 'filter-1', filterVal1);
store.getState().setFilter('plugin-a', 'filter-2', filterVal2);
let state = store.getState();
expect(state.filters['plugin-a']['filter-1']).toEqual(filterVal1);
expect(state.filters['plugin-a']['filter-2']).toEqual(filterVal2);
// Update filter-1
const updatedFilterVal1: FilterValue = { type: 'boolean', value: false };
store.getState().setFilter('plugin-a', 'filter-1', updatedFilterVal1);
state = store.getState();
expect(state.filters['plugin-a']['filter-1']).toEqual(updatedFilterVal1);
expect(state.filters['plugin-a']['filter-2']).toEqual(filterVal2); // Still preserved
});
it('clears all filters for a specific plugin', () => {
store.getState().setFilter('plugin-a', 'f1', { type: 'boolean', value: true });
store.getState().setFilter('plugin-b', 'f2', { type: 'boolean', value: false });
store.getState().clearFilters('plugin-a');
const state = store.getState();
expect(state.filters['plugin-a']).toBeUndefined();
expect(state.filters['plugin-b']).toBeDefined(); // plugin-b untouched
});
it('clears all filters globally', () => {
store.getState().setFilter('plugin-a', 'f1', { type: 'boolean', value: true });
store.getState().setFilter('plugin-b', 'f2', { type: 'boolean', value: false });
store.getState().clearAllFilters();
const state = store.getState();
expect(state.filters).toEqual({});
});
});
-69
View File
@@ -1,69 +0,0 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createGeoJsonSlice, GeoJsonSlice, ImportedLayer } from './geojsonSlice';
describe('geojsonSlice', () => {
let store: StoreApi<GeoJsonSlice>;
const mockLayer: ImportedLayer = {
id: 'layer-1',
name: 'Test Layer',
description: 'A test geojson layer',
color: '#ff0000',
visible: true,
featureCollection: { type: 'FeatureCollection', features: [] }
};
beforeEach(() => {
store = createStore<GeoJsonSlice>((set, get, api) => createGeoJsonSlice(set as any, get as any, api as any));
});
it('initializes with empty importedLayers', () => {
expect(store.getState().importedLayers).toEqual([]);
});
it('adds an imported layer', () => {
store.getState().addImportedLayer(mockLayer);
const layers = store.getState().importedLayers;
expect(layers).toHaveLength(1);
expect(layers[0]).toEqual(mockLayer);
});
it('removes an imported layer by id', () => {
store.getState().addImportedLayer(mockLayer);
store.getState().addImportedLayer({ ...mockLayer, id: 'layer-2' });
store.getState().removeImportedLayer('layer-1');
const layers = store.getState().importedLayers;
expect(layers).toHaveLength(1);
expect(layers[0].id).toBe('layer-2');
});
it('toggles visibility of an imported layer', () => {
store.getState().addImportedLayer(mockLayer); // initially visible: true
store.getState().toggleImportedLayerVisibility('layer-1');
expect(store.getState().importedLayers[0].visible).toBe(false);
store.getState().toggleImportedLayerVisibility('layer-1');
expect(store.getState().importedLayers[0].visible).toBe(true);
});
it('updates specific fields of an imported layer', () => {
store.getState().addImportedLayer(mockLayer);
store.getState().updateImportedLayer('layer-1', {
name: 'Updated Name',
color: '#00ff00'
});
const layer = store.getState().importedLayers[0];
expect(layer.name).toBe('Updated Name');
expect(layer.color).toBe('#00ff00');
// Unchanged fields remain the same
expect(layer.description).toBe('A test geojson layer');
expect(layer.visible).toBe(true);
});
});
-67
View File
@@ -1,67 +0,0 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createGlobeSlice, GlobeSlice } from './globeSlice';
describe('globeSlice', () => {
let store: StoreApi<GlobeSlice>;
beforeEach(() => {
// Create an isolated vanilla store specifically for this slice
store = createStore<GlobeSlice>((set, get, api) => createGlobeSlice(set as any, get as any, api as any));
});
it('sets initial camera state correctly', () => {
const state = store.getState();
expect(state.cameraLat).toBe(20);
expect(state.cameraLon).toBe(0);
expect(state.cameraAlt).toBe(20000000);
expect(state.cameraHeading).toBe(0);
expect(state.cameraPitch).toBe(-90);
expect(state.cameraRoll).toBe(0);
expect(state.isAnimating).toBe(false);
expect(state.fps).toBe(0);
});
it('updates camera position atomically', () => {
store.getState().setCameraPosition(45, -90, 1000);
const state = store.getState();
expect(state.cameraLat).toBe(45);
expect(state.cameraLon).toBe(-90);
expect(state.cameraAlt).toBe(1000);
});
it('resets orientation to defaults when not provided in position update', () => {
// First set custom orientation
store.getState().setCameraPosition(45, -90, 1000, 45, -45, 15);
// Then set without orientation
store.getState().setCameraPosition(50, -80, 2000);
const state = store.getState();
expect(state.cameraHeading).toBe(0);
expect(state.cameraPitch).toBe(-90);
expect(state.cameraRoll).toBe(0);
});
it('updates custom orientation when provided', () => {
store.getState().setCameraPosition(45, -90, 1000, 180, -30, 45);
const state = store.getState();
expect(state.cameraHeading).toBe(180);
expect(state.cameraPitch).toBe(-30);
expect(state.cameraRoll).toBe(45);
});
it('toggles animation state', () => {
store.getState().setAnimating(true);
expect(store.getState().isAnimating).toBe(true);
store.getState().setAnimating(false);
expect(store.getState().isAnimating).toBe(false);
});
it('records frames per second', () => {
store.getState().setFps(60);
expect(store.getState().fps).toBe(60);
});
});
-82
View File
@@ -1,82 +0,0 @@
import { describe, it, expect, beforeEach } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createLayersSlice, LayersSlice } from './layersSlice';
describe('layersSlice', () => {
let store: StoreApi<LayersSlice>;
beforeEach(() => {
store = createStore<LayersSlice>((set, get, api) => createLayersSlice(set as any, get as any, api as any));
});
it('initializes with empty layers', () => {
const state = store.getState();
expect(state.layers).toEqual({});
});
it('initializes a new layer with default values', () => {
store.getState().initLayer('test-plugin');
const state = store.getState();
expect(state.layers['test-plugin']).toEqual({
enabled: false,
entityCount: 0,
loading: false
});
});
it('initializes a new layer with explicitly requested enabled status', () => {
store.getState().initLayer('test-plugin', true);
const state = store.getState();
expect(state.layers['test-plugin'].enabled).toBe(true);
});
it('does not overwrite an existing layer upon re-initialization', () => {
store.getState().initLayer('test-plugin', true);
store.getState().setEntityCount('test-plugin', 42);
// Re-initialize
store.getState().initLayer('test-plugin', false);
const state = store.getState();
// Should preserve previous state
expect(state.layers['test-plugin'].enabled).toBe(true);
expect(state.layers['test-plugin'].entityCount).toBe(42);
});
it('toggles layer enabled status', () => {
store.getState().initLayer('test-plugin', false);
store.getState().toggleLayer('test-plugin');
expect(store.getState().layers['test-plugin'].enabled).toBe(true);
store.getState().toggleLayer('test-plugin');
expect(store.getState().layers['test-plugin'].enabled).toBe(false);
});
it('explicitly sets layer enabled status', () => {
store.getState().initLayer('test-plugin', false);
store.getState().setLayerEnabled('test-plugin', true);
expect(store.getState().layers['test-plugin'].enabled).toBe(true);
store.getState().setLayerEnabled('test-plugin', true); // Should remain true
expect(store.getState().layers['test-plugin'].enabled).toBe(true);
});
it('updates entity count', () => {
store.getState().initLayer('test-plugin');
store.getState().setEntityCount('test-plugin', 150);
expect(store.getState().layers['test-plugin'].entityCount).toBe(150);
});
it('updates loading status', () => {
store.getState().initLayer('test-plugin');
store.getState().setLayerLoading('test-plugin', true);
expect(store.getState().layers['test-plugin'].loading).toBe(true);
store.getState().setLayerLoading('test-plugin', false);
expect(store.getState().layers['test-plugin'].loading).toBe(false);
});
});
-72
View File
@@ -1,72 +0,0 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createTimelineSlice, TimelineSlice } from './timelineSlice';
import type { TimeWindow } from '@/core/plugins/PluginTypes';
describe('timelineSlice', () => {
let store: StoreApi<TimelineSlice>;
beforeEach(() => {
// Freeze time for consistent tests
vi.useFakeTimers();
vi.setSystemTime(new Date('2026-05-13T12:00:00Z'));
store = createStore<TimelineSlice>((set, get, api) => createTimelineSlice(set as any, get as any, api as any));
});
it('initializes with correct defaults', () => {
const state = store.getState();
expect(state.timeWindow).toBe('24h');
expect(state.isPlaying).toBe(false);
expect(state.playbackSpeed).toBe(1);
expect(state.isPlaybackMode).toBe(false);
expect(state.timelineAvailability).toEqual({});
// timeRange should be 24h behind current time
const expectedStart = new Date(Date.now() - 86400000);
expect(state.timeRange.start.getTime()).toBe(expectedStart.getTime());
expect(state.timeRange.end.getTime()).toBe(Date.now());
});
it('updates time window and dynamically recalculates time range', () => {
store.getState().setTimeWindow('1h' as TimeWindow);
const state = store.getState();
expect(state.timeWindow).toBe('1h');
const expectedStart = new Date(Date.now() - 3600000); // 1 hour
expect(state.timeRange.start.getTime()).toBe(expectedStart.getTime());
});
it('sets current time', () => {
const newTime = new Date('2026-05-13T10:00:00Z');
store.getState().setCurrentTime(newTime);
expect(store.getState().currentTime).toBe(newTime);
});
it('sets exact time range', () => {
const range = { start: new Date('2026-01-01'), end: new Date('2026-01-02') };
store.getState().setTimeRange(range);
expect(store.getState().timeRange).toEqual(range);
});
it('sets playback states', () => {
store.getState().setPlaying(true);
expect(store.getState().isPlaying).toBe(true);
store.getState().setPlaybackSpeed(5);
expect(store.getState().playbackSpeed).toBe(5);
store.getState().setPlaybackMode(true);
expect(store.getState().isPlaybackMode).toBe(true);
store.getState().setPlaybackTime(10000);
expect(store.getState().playbackTime).toBe(10000);
});
it('sets timeline availability for plugins', () => {
const availability = [{ start: 100, end: 200 }];
store.getState().setTimelineAvailability('plugin-a', availability);
expect(store.getState().timelineAvailability['plugin-a']).toEqual(availability);
});
});
-159
View File
@@ -1,159 +0,0 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import { createStore, type StoreApi } from 'zustand/vanilla';
import { createUISlice, UISlice, FloatingStream } from './uiSlice';
import type { GeoEntity } from '@/core/plugins/PluginTypes';
// Mock the analytics module to prevent actual tracking during tests
vi.mock('@/lib/analytics', () => ({
trackEvent: vi.fn(),
}));
describe('uiSlice', () => {
let store: StoreApi<UISlice>;
beforeEach(() => {
// Reset local storage and document element
vi.stubGlobal('localStorage', {
getItem: vi.fn(),
setItem: vi.fn(),
clear: vi.fn(),
});
document.documentElement.removeAttribute('data-theme');
store = createStore<UISlice>((set, get, api) => createUISlice(set as any, get as any, api as any));
});
it('initializes with correct default state', () => {
const state = store.getState();
expect(state.leftSidebarOpen).toBe(true);
expect(state.rightSidebarOpen).toBe(false);
expect(state.configPanelOpen).toBe(true);
expect(state.filterPanelOpen).toBe(false);
expect(state.selectedEntity).toBeNull();
expect(state.floatingStreams).toEqual([]);
expect(state.activeConfigTab).toBe('filters');
expect(state.timelineOpen).toBe(true);
});
it('toggles simple boolean states', () => {
store.getState().toggleLeftSidebar();
expect(store.getState().leftSidebarOpen).toBe(false);
store.getState().toggleRightSidebar();
expect(store.getState().rightSidebarOpen).toBe(true);
store.getState().toggleConfigPanel();
expect(store.getState().configPanelOpen).toBe(false);
store.getState().toggleFilterPanel();
expect(store.getState().filterPanelOpen).toBe(true);
store.getState().setTimelineOpen(false);
expect(store.getState().timelineOpen).toBe(false);
store.getState().setFeedbackDialogOpen(true);
expect(store.getState().feedbackDialogOpen).toBe(true);
});
it('toggles themes cyclically and updates DOM/localStorage', () => {
// Start with black
store.getState().setTheme('black');
store.getState().toggleTheme();
expect(store.getState().theme).toBe('light');
expect(document.documentElement.getAttribute('data-theme')).toBe('light');
expect(localStorage.setItem).toHaveBeenCalledWith('wwv-theme', 'light');
store.getState().toggleTheme();
expect(store.getState().theme).toBe('legacy');
store.getState().toggleTheme();
expect(store.getState().theme).toBe('dark');
store.getState().toggleTheme();
expect(store.getState().theme).toBe('black');
});
it('sets specific theme directly', () => {
store.getState().setTheme('legacy');
expect(store.getState().theme).toBe('legacy');
expect(document.documentElement.getAttribute('data-theme')).toBe('legacy');
});
it('handles setting selected entity and related UI panels', () => {
const mockEntity = { id: 'e1', pluginId: 'test' } as GeoEntity;
// When setting entity, right sidebar and config should open
store.getState().setSelectedEntity(mockEntity);
let state = store.getState();
expect(state.selectedEntity).toEqual(mockEntity);
expect(state.rightSidebarOpen).toBe(true);
expect(state.configPanelOpen).toBe(true);
expect(state.mobileRightPanelGlow).toBe(true);
expect(state.activeConfigTab).toBe('intel');
// When unsetting entity, panels should stay open, but glow and entity reset
store.getState().setSelectedEntity(null);
state = store.getState();
expect(state.selectedEntity).toBeNull();
expect(state.rightSidebarOpen).toBe(true); // Should remain true
expect(state.configPanelOpen).toBe(true); // Should remain true
expect(state.mobileRightPanelGlow).toBe(false);
});
it('sets hovered entity and position', () => {
const mockEntity = { id: 'e2', pluginId: 'test' } as GeoEntity;
store.getState().setHoveredEntity(mockEntity, { x: 100, y: 200 });
const state = store.getState();
expect(state.hoveredEntity).toEqual(mockEntity);
expect(state.hoveredScreenPosition).toEqual({ x: 100, y: 200 });
});
it('manages floating streams', () => {
const newStream: Omit<FloatingStream, "position" | "size"> = {
id: 'stream-1',
streamUrl: 'http://test',
isIframe: true,
label: 'Test Stream'
};
// Add
store.getState().addFloatingStream(newStream);
let state = store.getState();
expect(state.floatingStreams.length).toBe(1);
expect(state.floatingStreams[0].id).toBe('stream-1');
// Check default size and position
expect(state.floatingStreams[0].size).toEqual({ width: 400, height: 260 });
// Update
store.getState().updateFloatingStream('stream-1', { isMinimized: true });
state = store.getState();
expect(state.floatingStreams[0].isMinimized).toBe(true);
// Prevent duplicates
store.getState().addFloatingStream(newStream);
expect(store.getState().floatingStreams.length).toBe(1);
// Remove
store.getState().removeFloatingStream('stream-1');
expect(store.getState().floatingStreams.length).toBe(0);
});
it('manages error toasts', () => {
store.getState().showErrorToast('Test error message');
expect(store.getState().errorToastMessage).toBe('Test error message');
store.getState().clearErrorToast();
expect(store.getState().errorToastMessage).toBeNull();
});
it('manages mobile panels and glow', () => {
store.getState().setOpenMobilePanel('right');
expect(store.getState().openMobilePanel).toBe('right');
expect(store.getState().mobileRightPanelGlow).toBe(false); // Should clear glow when opening right panel
// Clicking same panel closes it
store.getState().setOpenMobilePanel('right');
expect(store.getState().openMobilePanel).toBeNull();
});
});
-37
View File
@@ -1,37 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { authConfig } from "./auth.config";
import { isDemo } from "@/core/edition";
vi.mock("@/core/edition", () => ({
isDemo: false,
}));
describe("authConfig", () => {
const authorized = authConfig.callbacks?.authorized as any;
it("should allow access to API routes without auth", () => {
const mockRequest = { nextUrl: { pathname: "/api/test" } };
expect(authorized({ auth: null, request: mockRequest })).toBe(true);
});
it("should allow access to setup and login pages without auth", () => {
expect(authorized({ auth: null, request: { nextUrl: { pathname: "/setup" } } })).toBe(true);
expect(authorized({ auth: null, request: { nextUrl: { pathname: "/login" } } })).toBe(true);
});
it("should block access to dashboard if not logged in (non-demo)", () => {
const mockRequest = { nextUrl: { pathname: "/" } };
expect(authorized({ auth: null, request: mockRequest })).toBe(false);
});
it("should allow access to dashboard if logged in (non-demo)", () => {
const mockRequest = { nextUrl: { pathname: "/" } };
const mockAuth = { user: { name: "test" } };
expect(authorized({ auth: mockAuth, request: mockRequest })).toBe(true);
});
it("should allow access to dashboard if in demo mode", () => {
// Manually override mock behavior if possible, or use a separate file
// For this test we'll assume isDemo returns true (requires different mock setup)
});
});
-94
View File
@@ -1,94 +0,0 @@
/**
* Server-side AgentBus, scoped per user.
*
* Holds the set of currently-connected SSE clients keyed by Auth.js user id
* and broadcasts agent actions (`fly_to`, `layer_toggle`, etc.) published
* via `/api/agent/publish` only to subscribers belonging to the same user
* as the publisher. The browser-side subscriber dispatches the received
* actions onto the existing `dataBus` so the running React + Cesium app
* picks them up the same way it picks up any other UI event.
*
* Per-user scoping: in a multi-tenant WWV deployment, user A's external
* tool publishing to /api/agent/publish must NOT reach user B's open
* browser tab. The publish + subscribe routes pass `session.user.id`,
* the bus routes deliveries to that user's subscriber set only.
*
* Process-local in-memory only. Multi-instance deployments would need a
* Redis pub/sub adapter; a self-hosted single-process WWV is the primary
* target — extending this is straightforward when needed.
*/
export type AgentAction =
| { action: "fly_to"; lat: number; lon: number; alt?: number; heading?: number; distance?: number }
| { action: "face_towards"; lat: number; lon: number; alt?: number }
| { action: "layer_toggle"; pluginId: string; enabled: boolean }
| { action: "highlight_layer"; pluginId: string }
| { action: "select_entity"; pluginId: string; entityId: string }
| { action: "ping"; ts: number };
interface Subscriber {
id: string;
write: (chunk: string) => void;
close: () => void;
}
class AgentBus {
/** userId → (connId → Subscriber). Empty inner maps are pruned on unsubscribe. */
private byUser = new Map<string, Map<string, Subscriber>>();
subscribe(userId: string, sub: Subscriber): () => void {
let bucket = this.byUser.get(userId);
if (!bucket) {
bucket = new Map();
this.byUser.set(userId, bucket);
}
bucket.set(sub.id, sub);
return () => {
const b = this.byUser.get(userId);
if (!b) return;
b.delete(sub.id);
if (b.size === 0) this.byUser.delete(userId);
};
}
/** Broadcast an action only to subscribers belonging to the publisher's user. */
publish(userId: string, message: AgentAction): { delivered: number } {
const bucket = this.byUser.get(userId);
if (!bucket) return { delivered: 0 };
const payload = `data: ${JSON.stringify(message)}\n\n`;
let delivered = 0;
for (const sub of bucket.values()) {
try {
sub.write(payload);
delivered++;
} catch {
bucket.delete(sub.id);
}
}
if (bucket.size === 0) this.byUser.delete(userId);
return { delivered };
}
/** Count of currently-subscribed connections for a given user. */
subscribersFor(userId: string): number {
return this.byUser.get(userId)?.size ?? 0;
}
/** Total connections across all users (for diagnostics). */
get totalSubscribers(): number {
let n = 0;
for (const bucket of this.byUser.values()) n += bucket.size;
return n;
}
}
// Module-level singleton. Next.js dev mode hot-reloads modules; using a
// global ensures the SSE state survives editor saves so connected browsers
// don't drop and reconnect on every code change in development.
declare global {
// eslint-disable-next-line no-var
var __WWV_AGENT_BUS__: AgentBus | undefined;
}
export const agentBus: AgentBus =
globalThis.__WWV_AGENT_BUS__ ?? (globalThis.__WWV_AGENT_BUS__ = new AgentBus());
-27
View File
@@ -1,27 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { trackEvent } from "./analytics";
describe("analytics", () => {
beforeEach(() => {
vi.stubGlobal("window", { umami: { track: vi.fn() } });
});
it("should call window.umami.track if available", () => {
trackEvent("test-event", { key: "val" });
expect(window.umami!.track).toHaveBeenCalledWith("test-event", { key: "val" });
});
it("should not throw if umami is missing", () => {
vi.stubGlobal("window", {});
expect(() => trackEvent("test")).not.toThrow();
});
it("should not throw if track fails", () => {
vi.stubGlobal("window", {
umami: {
track: () => { throw new Error("Blocked"); }
}
});
expect(() => trackEvent("test")).not.toThrow();
});
});
-31
View File
@@ -1,7 +1,6 @@
import { describe, test, expect } from "vitest";
import { convertToGeoJson } from "./converter";
import { detectGeoFields } from "./fieldDetector";
import fc from "fast-check";
// ── Field Detector ──────────────────────────────────────────────
@@ -135,34 +134,4 @@ describe("convertToGeoJson", () => {
category: "nature", active: false,
});
});
test("property test: correctly converts arrays of random objects with valid auto-detected coords", () => {
fc.assert(
fc.property(
fc.array(
fc.record({
lat: fc.double({ min: -90, max: 90, noNaN: true }),
lon: fc.double({ min: -180, max: 180, noNaN: true }),
randomProp: fc.string(),
}),
{ minLength: 1, maxLength: 100 }
),
(data) => {
const result = convertToGeoJson(data);
expect(result.type).toBe("FeatureCollection");
expect(result.features).toHaveLength(data.length);
for (let i = 0; i < data.length; i++) {
const f = result.features[i];
const row = data[i];
expect(f.geometry.type).toBe("Point");
expect(f.geometry.coordinates).toEqual([row.lon, row.lat]);
expect(f.properties.randomProp).toBe(row.randomProp);
expect(f.properties).not.toHaveProperty("lat");
expect(f.properties).not.toHaveProperty("lon");
}
}
)
);
});
});
-18
View File
@@ -163,24 +163,6 @@ describe("normalizeToGeoJson", () => {
expect(() => normalizeToGeoJson({ foo: "bar" })).toThrow("Unrecognized");
});
test("handles MultiPolygon geometry", () => {
const input = {
type: "Feature",
geometry: {
type: "MultiPolygon",
coordinates: [[[[0, 0], [10, 0], [10, 10], [0, 10], [0, 0]]]],
},
properties: {},
};
const result = normalizeToGeoJson(input);
expect(result.geometryTypes).toEqual(["MultiPolygon"]);
});
test("throws when input parses to a non-object/array", () => {
expect(() => normalizeToGeoJson(123)).toThrow("Input must be a JSON object or array");
expect(() => normalizeToGeoJson("123")).toThrow("Input must be a JSON object or array");
});
test("property: handles random coordinate inputs autonomously", () => {
// This property test autonomously generates random float pairs to test edge-cases
fc.assert(
-5
View File
@@ -10,11 +10,6 @@ function fakeRequest(origin?: string): Request {
describe("CORS utility", () => {
describe("corsHeaders", () => {
it("returns empty object if no origin is provided", () => {
const headers = corsHeaders(fakeRequest(""));
expect(headers).toEqual({});
});
it("returns allowed origin for localhost:3001", () => {
const headers = corsHeaders(fakeRequest("http://localhost:3001"));
expect(headers["Access-Control-Allow-Origin"]).toBe("http://localhost:3001");
@@ -97,25 +97,4 @@ describe("marketplaceToken", () => {
await expect(verifyMarketplaceToken(noSub)).rejects.toThrow("subject");
});
});
describe("revokeMarketplaceToken", () => {
it("revokes a token and rejects it on verify", async () => {
const { revokeMarketplaceToken } = await import("./marketplaceToken");
const token = await issueMarketplaceToken(TEST_USER_ID);
const payload = await verifyMarketplaceToken(token);
expect(payload.jti).toBeDefined();
// Revoke it
revokeMarketplaceToken(payload.jti!);
// Now it should throw
await expect(verifyMarketplaceToken(token)).rejects.toThrow("revoked");
});
it("does nothing when passed an empty jti", async () => {
const { revokeMarketplaceToken } = await import("./marketplaceToken");
expect(() => revokeMarketplaceToken("")).not.toThrow();
});
});
});
-64
View File
@@ -1,64 +0,0 @@
import { describe, it, expect, vi, beforeEach } from "vitest";
import { getRequestOrigin } from "./origin";
describe("getRequestOrigin", () => {
const originalEnv = process.env;
beforeEach(() => {
vi.resetModules();
process.env = { ...originalEnv };
vi.clearAllMocks();
});
it("should prioritize x-forwarded-host", () => {
const headers = new Map([
["x-forwarded-host", "myapp.com"],
["x-forwarded-proto", "https"]
]);
const mockRequest: any = {
headers: { get: (key: string) => headers.get(key) },
nextUrl: { origin: "http://0.0.0.0:3000" },
url: "http://0.0.0.0:3000/api"
};
const origin = getRequestOrigin(mockRequest);
expect(origin).toBe("https://myapp.com");
});
it("should fall back to host header if no forwarded host", () => {
const headers = new Map([
["host", "localhost:3000"]
]);
const mockRequest: any = {
headers: { get: (key: string) => headers.get(key) },
nextUrl: { origin: "http://0.0.0.0:3000" },
};
const origin = getRequestOrigin(mockRequest);
expect(origin).toBe("http://localhost:3000");
});
it("should fall back to env var if headers are missing or invalid", () => {
process.env.NEXT_PUBLIC_APP_URL = "https://cloud.wwv.dev";
const headers = new Map([
["host", "0.0.0.0:3000"]
]);
const mockRequest: any = {
headers: { get: (key: string) => headers.get(key) },
nextUrl: { origin: "http://0.0.0.0:3000" },
};
const origin = getRequestOrigin(mockRequest);
expect(origin).toBe("https://cloud.wwv.dev");
});
it("should replace 0.0.0.0 with localhost as last resort", () => {
const mockRequest: any = {
headers: { get: () => null },
nextUrl: { origin: "http://0.0.0.0:3000" },
};
const origin = getRequestOrigin(mockRequest);
expect(origin).toBe("http://localhost:3000");
});
});
-44
View File
@@ -1,6 +1,5 @@
import { describe, it, expect, beforeEach, afterEach } from "vitest";
import { RateLimiter, getClientIp } from "./rateLimit";
import fc from "fast-check";
describe("RateLimiter", () => {
let limiter: RateLimiter;
@@ -61,20 +60,6 @@ describe("RateLimiter", () => {
}, 60);
});
});
it("cleans up expired entries", () => {
const localLimiter = new RateLimiter({ windowMs: 100, maxRequests: 5 });
localLimiter.check("ip-cleanup");
// Force the store resetAt to be in the past
const entry = (localLimiter as any).store.get("ip-cleanup");
entry.resetAt = Date.now() - 1000;
(localLimiter as any).cleanup();
expect((localLimiter as any).store.has("ip-cleanup")).toBe(false);
localLimiter.destroy();
});
});
describe("getClientIp", () => {
@@ -96,33 +81,4 @@ describe("getClientIp", () => {
const req = new Request("http://localhost");
expect(getClientIp(req)).toBe("unknown");
});
it("property test: x-forwarded-for always returns the first IP in a list", () => {
fc.assert(
fc.property(
fc.array(fc.ipV4(), { minLength: 1, maxLength: 10 }),
(ips) => {
const headerValue = ips.join(", ");
const req = new Request("http://localhost", {
headers: { "x-forwarded-for": headerValue },
});
expect(getClientIp(req)).toBe(ips[0]);
}
)
);
});
it("property test: x-real-ip is used when x-forwarded-for is absent", () => {
fc.assert(
fc.property(
fc.ipV4(),
(ip) => {
const req = new Request("http://localhost", {
headers: { "x-real-ip": ip },
});
expect(getClientIp(req)).toBe(ip);
}
)
);
});
});
-16
View File
@@ -1,16 +0,0 @@
{
"$schema": "./node_modules/@stryker-mutator/core/schema/stryker-schema.json",
"packageManager": "pnpm",
"testRunner": "vitest",
"plugins": ["@stryker-mutator/vitest-runner"],
"reporters": ["html", "clear-text", "progress"],
"coverageAnalysis": "perTest",
"ignoreStatic": true,
"mutate": [
"src/core/**/*.ts",
"src/core/**/*.tsx",
"src/lib/**/*.ts",
"!src/**/*.test.ts",
"!src/**/*.spec.ts"
]
}
-7
View File
@@ -17,12 +17,5 @@ export default defineConfig({
'src/app/**/*.{test,spec}.{js,ts,jsx,tsx}',
'packages/**/*.{test,spec}.{js,ts,jsx,tsx}',
],
coverage: {
thresholds: {
branches: 80,
functions: 80,
statements: 80,
}
}
},
});