6.8 KiB
Product Requirements Document (PRD) Star Citizen AUEC Price Index Tracker
Unified Modern TypeScript Stack + Electron Desktop Application
- Product Overview
This product is a cross-platform desktop application (Electron + React/TSX) that displays real-money trading (RMT) prices for Star Citizen AUEC. A modern TypeScript-based backend performs scraping, normalization, time-series storage, and API hosting.
The goal is to generate a reliable AUEC Price Index, similar in spirit to a financial market index, and visualize it in a Bloomberg-style terminal UI that includes tables, charts, and alerts.
Alerts are evaluated client-side, based on data received from the backend.
- Goals & Non-Goals Goals
Scrape AUEC prices from:
Eldorado
PlayerAuctions
Normalize them into a USD ↔ AUEC Price Index.
Provide REST + WebSocket API to clients.
Display Bloomberg-like UI using Electron + React.
Allow users to set local alerts (no backend evaluation).
Store long-term historical price data.
Non-Goals
Buying/selling AUEC inside the app.
Mobile or web app (desktop only).
Legal/regulatory RMT analysis.
Server-side alert evaluation.
- System Architecture [Scraper Services - TypeScript + Playwright] | v [Backend API - Fastify/NestJS - TypeScript]
- Normalize prices
- Store historical data (PostgreSQL + TimescaleDB)
- Expose REST + WebSocket | v [Electron Desktop App - React/TSX UI]
- Bloomberg-style terminal interface
- Client-side alerts
- Charting & vendor tables
- Detailed Requirements 4.1 Scraping Module (Backend) Technology
TypeScript
Playwright for dynamic scraping
Node Scheduler or BullMQ for job scheduling
Deployed as containers (Docker)
Scraping Frequency
Every 5 minutes (configurable per environment)
Scraping Targets
Eldorado AUEC Market https://www.eldorado.gg/star-citizen-auec/g/141-0-0
PlayerAuctions AUEC Market https://www.playerauctions.com/star-citizen-auec/
Scraped Data Fields
Vendor name
Listing price (USD)
AUEC amount per listing
Derived:
USD per 1 million AUEC
AUEC per USD
Timestamp
Listing min/max spread (if available)
Scraper Requirements
Headless mode with Playwright Chromium
Randomized UA + viewport
Retry logic (3 attempts)
Automatically detect layout changes (optional heuristics)
Error Handling
Failures logged to DB
Continue schedule regardless of scrape results
4.2 Backend Server (TypeScript) Technology Stack
Node.js + TypeScript
Fastify or NestJS (dev’s choice)
WebSockets via native ws or Fastify WS plugin
PostgreSQL + TimescaleDB for time-series storage
Prisma or Drizzle ORM
Backend Responsibilities
Accept scraped data
Compute Price Index
Store time-series data
Serve historical & latest prices
Push WS updates to connected Electron clients
Price Index Formula
Default:
lowest_price = min(USD_per_million_AUEC_from_all_vendors)
All individual listings are stored with seller and platform information for historical tracking and comparison.
REST API Endpoints
GET /prices/latest - Get all current listings with seller info
GET /prices/lowest - Get current lowest price across all vendors
GET /prices/by-seller?seller=&platform= - Get specific seller's price history
GET /prices/by-platform?platform= - Get all listings from a platform
GET /prices/history?from=&to=&seller=&platform= - Historical data with filters
GET /index/history?range=7d|30d|90d|all - Lowest price over time
WebSocket Channels
/ws/index → broadcast each new scrape
/ws/vendors → vendor-level updates
Performance Requirements
Handle 5000+ concurrent WS connections
API latency < 50ms for standard queries
4.3 Database Layer Database
PostgreSQL (core DB)
TimescaleDB extension for time-series compression & fast queries
Schema raw_vendor_prices field type id uuid timestamp timestamptz vendor text (eldorado/playerauctions) seller_name text usd_price numeric auec_amount numeric usd_per_million numeric delivery_time text url text price_index field type timestamp timestamptz lowest_price numeric vendor text seller_name text scrape_log field type timestamp timestamptz status text (success/failure) message text runtime_ms int
4.4 Electron Desktop App (React/TSX) Technology Stack
Electron 30+
React + TypeScript/TSX
Vite build tooling
TailwindCSS for styling
Recharts, ECharts, or TradingView Charting Library for visuals
Zustand/Recoil for state management
Main Features Dashboard (Bloomberg-style)
Large real-time Price Index number
Color-coded trend (% change)
Mini sparkline
Vendor Comparison Table
Columns:
Platform (Eldorado/PlayerAuctions)
Seller Name
USD per 1M AUEC
Delivery Time
Last updated
Sortable by price, seller, platform
Filter by platform
Auto-refresh from WebSocket events
Historical Chart
Select by:
Lowest price across all vendors (default)
Specific platform (Eldorado/PlayerAuctions)
Specific seller
Chart types:
Line (price over time)
Area
Multi-line comparison (compare multiple sellers)
Time ranges:
1h, 6h, 24h, 7d, 30d, All
Show all seller prices as separate lines for comparison
Client-Side Alerts
User selects:
Condition:
Price rises above X
Price falls below X
Threshold value
Stored locally (JSON or SQLite)
Trigger rules:
On each WS update, re-evaluate alerts
Trigger:
Windows/macOS/Linux native notification
Sound (toggle in settings)
UI popup/log entry
Settings Panel
Dark/light mode
Alert sounds on/off
Launch on startup
Chart theme
Electron-Specific Requirements
Auto-update (e.g., using electron-updater)
Secure IPC messaging (no remote code eval)
Sandboxed renderer process
Signed binaries (Windows .exe, macOS .dmg/.pkg)
- Non-Functional Requirements Security
HTTPS for all API calls
No sensitive user data stored
Sanitized DB inputs
CSRF not needed (desktop app only)
Signed Electron builds
Scalability
Scrapers run in Docker for horizontal scaling
Backend stateless → easy to scale behind a load balancer
TimescaleDB handles time-series at scale
Reliability
WebSocket auto-reconnect
Graceful handling if server is offline
Retry logic in scraping pipeline
Performance
Desktop app must remain responsive when charts have 50k+ datapoints (handled with TimescaleDB downsampling + chart library performance)
Testing
Unit tests: Jest (backend & Electron renderer)
E2E tests: Playwright for UI
Integration tests for API via Supertest or Pact
- Risks & Mitigation Risk Mitigation Vendor site layout changes break scrapers Monitoring + abstraction layers + fallback parsing Browser automation instability Playwright retries + container isolation WS disconnects Auto-reconnect logic in Electron Heavy Electron UI Use Vite + lazy-loaded components + chart virtualization TimescaleDB complexity Can be optional if scale is small
- Future Enhancements
Add more RMT vendors
Discord alerts via webhook
Predictive modeling (ML)
Add terminal-like command bar (e.g., /chart index 30d)
Desktop widgets and system tray “price ticker”