// TRADERVIEW — TRADERVUE-STYLE TRADING JOURNAL

Quickstart

Clone the repo, vendor uPlot, then pick a deploy target:

# 1. clone + vendor uPlot
git clone https://github.com/MenkeTechnologies/traderview
cd traderview
./scripts/vendor-uplot.sh

# 2a. desktop — Tauri v2, embedded Postgres
cargo tauri dev          # first launch downloads PostgreSQL (~80 MB)

# 2b. web — axum, external Postgres
docker compose up -d postgres
export DATABASE_URL=postgres://traderview:traderview@localhost:5432/traderview
export TRADERVIEW_JWT_SECRET=$(openssl rand -hex 32)
cargo run -p traderview-web --bin server
# open http://localhost:8080

The desktop app is a single user, fully offline. The web binary is multi-user with registration and JWT bearer auth. Same schema, same migrations, same FIFO roll-up, same frontend, same API surface.

Architecture — One Workspace, Two Deploy Targets

The desktop and web binaries are thin shells. All domain logic, all SQL, all broker parsing lives in the three library crates. The decision "embedded vs external Postgres" and "local auto-user vs multi-user with auth" is the only thing that distinguishes them.

Crate Graph

Schema — 83 Tables, 38 Migrations

Migrations under migrations/0001_initial.sql through 0046_budgets.sql — each one adds a self-contained feature. Money is NUMERIC(20, 8) everywhere. 91 base tables, 130 indexes, 24 PostgreSQL enum types. Grouped by domain:

Enum types (24): sides (side_t, trade_side_t), statuses (trade_status_t, order_status_t, review_status_t), asset classes, alert triggers, sentiment sources, halt reason codes, etc. — see migrations/0001_initial.sql and feature-incremental migrations for the full set.

HTTP API — 1,865 Routes Under /api/

89 route files in crates/traderview-web/src/routes/. Bearer-auth required on everything except /health, /config, /auth/*, and /client-errors. WebSocket endpoints expose live feeds. Grouped by domain (representative endpoints — see frontend/js/api.js for the full method-bound bindings):

Desktop mode binds to a random localhost port and auto-logs in as the local user. Web mode requires POST /api/auth/login → JWT → Authorization: Bearer …. A custom request/response logging middleware records every request with elapsed_ms; 4xx/5xx responses get a 4KB body snippet attached to the log entry for offline debugging.

Frontend — Vanilla JS + uPlot, 641 Views, 644-Tile Launcher

Zero npm. Zero bundler. Zero JS framework. 239,580 LOC vanilla ES modules + 3,898 LOC CSS served as static files. axum's tower-http fs middleware in web mode; Tauri loads from disk via custom tauri://localhost scheme in desktop mode.

The launcher (Cmd+K) is the entry point — 646 tiles across 10 categories with a live-filter search and Enter-jumps-to-first-match. There is no fixed nav strip; the topbar carries 11 shortcuts and the rest is the launcher.

Race-safe view dispatch. app.js maintains a per-dispatch token (currentViewToken()) bumped on every navigation. Every view captures the token at render start and bails after each await if the token is stale — prevents the "document.getElementById(...) returns null after navigation" crash that hits naïve SPAs when slow async resolves into a replaced DOM.

js/api.js wraps fetch with auth, error reporting, JSON parsing, and an ApiError class. js/error_reporter.js funnels window.onerror, unhandledrejection, and overridden console.error to POST /api/client-errors, queue-capped at 200 to survive a console-error loop. uPlot vendored under frontend/lib/ — pinned, reproducible, no CDN at runtime.

Importing — 12 Brokers + Column-Mapping Wizard

Built-in parsers (crates/traderview-import/src/brokers.rs):

• Webull · Lightspeed · IBKR Flex · ThinkOrSwim · TD Ameritrade · Schwab · Fidelity · ETrade · Robinhood · TradeStation · DAS Trader · TradeZero · Generic (column-mapping wizard)

Pipeline per upload:

1. Raw rows + file hash recorded in imports for audit / re-parse.
2. Each row maps to an execution and inserts under (account_id, broker_order_id, executed_at, symbol, side, qty, price) — dedupe-safe.
3. FIFO roll-up re-runs for affected (account_id, symbol) pairs and rewrites trades.

Re-importing the same CSV is idempotent. Unknown brokers go through the CSV Wizard — you point at any CSV, the UI maps columns to execution fields (symbol / side / qty / price / executed_at / fees), and the mapping is saved per-broker per-user. Asset class is auto-detected from symbol patterns (options: SYMyyMMddCNNNN; futures: =F suffix; FX: =X suffix).

Live Data Streams — Polled Upstream, Pushed Downstream

Server-side pollers run on tokio tasks, push to in-process DashMap+broadcast stores, then fan out to browsers over WebSocket. All stores are bounded with oldest-first eviction (halts cap 2,000; catalysts cap 10,000) so multi-day sessions don't grow without limit.

Ticker extraction (catalyst NER) handles $SYM cashtags, parenthetical (SYM) with stop-word filter, and exchange-prefixed forms (NYSE:, NASDAQ:, AMEX:, OTC:). Halt reason codes (T1, T5, LUDP, MWC1/2/3, H10, …) are looked up in a static reason-code table for readable labels.

Resilience & Hardening

• Stale-lock recovery. Embedded Postgres checks postmaster.pid before start; if the recorded PID is dead, removes the lockfile so a SIGKILL'd parent doesn't permanently block the next launch.
• Persisted PG password. Random password file (mode 0600) in the data dir — initialized once, reused forever — so auth survives across launches.
• Backend held across axum::serve. The Embedded handle is owned by the worker thread for the lifetime of the server; explicit drop after serve. Earlier, the handle dropped at function exit and pg_ctl stop killed Postgres mid-request — every subsequent query timed out with "pool timed out".
• Real concurrency for multi-symbol fan-outs. premarket::snapshot + markets::snapshot + market_data::quotes + compare::compare all use futures_util::future::join_all — previously serial loops blocked /api/premarket/snapshot for 150 seconds and starved the pool.
• Pool sized for cold-start fan-out. max_connections=32, min_connections=4 (kept warm), acquire_timeout=15s.
• Per-view race tokens. Frontend dispatch increments a counter on every navigation; views bail post-await if their captured token is stale, preventing null-DOM crashes.
• Browser-side error sink. window.onerror, unhandledrejection, and overridden console.error all POST to /api/client-errors (queue-capped). The Rust log mirrors every browser failure.
• WebKit SecurityError guards. Under Tauri's tauri://localhost custom scheme, navigator.sendBeacon, Notification.requestPermission, new Notification, speechSynthesis.speak, and localStorage all throw cross-origin SecurityErrors. Each is try/caught so boot survives.
• CSP allows ws://127.0.0.1:* so WebSocket connections to the dynamic backend port aren't blocked under custom scheme.

Configuration

The desktop app stores its Postgres cluster under the OS-appropriate app-data directory: ~/Library/Application Support/com.menketechnologies.traderview/pg/ on macOS, ~/.local/share/com.menketechnologies.traderview/pg/ on Linux, %APPDATA%\com.menketechnologies.traderview\pg\ on Windows.

What's Built

What This Replaces

Built by MenkeTechnologies, part of the MenkeTechnologiesMeta stack alongside strykelang, zshrs, zpwr, and the broader Rust + CLI family.