DashForge

A JSON-first dashboard framework that starts simple with static hosting (GitHub Pages) and grows into a full Metabase-like analytics platform with an AI-powered visual builder.

Features

Core Platform

• 🎨 Visual Dashboard Builder - Drag-and-drop dashboard editor optimized for LLM agents
• 📄 JSON Dashboard IR - Non-polymorphic, AI-friendly dashboard definitions
• 🔗 Cube.js Semantic Layer - Business-friendly queries with pre-built relationships
• ⚡ Static or Dynamic - Start with static file hosting, graduate to PostgreSQL
• 🗄️ Multi-Database Support - Connect any PostgreSQL, MySQL/Dolt, or SQLite database through configuration alone via the built-in generic sql connector, or register custom plugin providers for application-specific stores
• ❓ Saved Questions - Metabase-style read-only GrokifyQL questions with formatting, syntax highlighting, field value browsing, CSV/XLSX export, and dashboard reuse
• 🤖 Agent-Ready Analytics - Integrates with OmniAgent marketplace primitives while DashForge owns query, field-value, and dashboard capabilities
• 🔑 Secret References - Analytics source credentials should use OmniVault/VaultGuard references instead of raw DSNs in catalog storage, with OmniVault SQL store as the encrypted-in-DB fallback
• 🏢 Multi-tenant - Row Level Security (RLS) for tenant isolation
• 🔐 SSO Authentication - GitHub and Google OAuth support
• 📊 ChartIR Integration - Uses echartify for charts

Template Marketplace

• 📦 Dashboard Templates - Publish and sell reusable dashboard templates
• 🏪 Publisher System - Organizations can become publishers with creator roles
• ✅ Template Licensing - Seat-based licensing for purchased templates
• 🔄 Version Control - Template versioning with auto-update options
• 🖼️ Preview & Screenshots - Gallery views for template discovery

Authorization

• 🔀 Dual-Mode Auth - Simple role hierarchy or SpiceDB for fine-grained control
• 🧭 Analytics Policy - SystemForge/SpiceDB-backed GrokifyQL policy for dataset and field permissions
• 👤 Publisher Roles - Owner, Admin, Creator, Reviewer hierarchies
• 👥 Consumer Roles - Owner, Admin, Editor, Viewer hierarchies
• 🎯 Resource Permissions - Granular control over dashboards, queries, alerts, integrations

Quick Start

Visual Dashboard Builder

The fastest way to create dashboards:

# Build the React dashboard builder
cd builder && npm install && npm run build && cd ..

# Start the server
go run ./cmd/dashforge-server serve --port 8080

# Open the builder
open http://localhost:8080/builder/

Static Mode (No Server)

Open viewer/index.html in a browser with a dashboard URL:

cd dashforge
python3 -m http.server 8080
# Open http://localhost:8080/viewer/?dashboard=../examples/compliance-dashboard.json

The viewer has a light/dark theme toggle (top-right, persisted via localStorage) and caps numeric display in tooltips, axis labels, and metric tiles to 2 decimal places.

Server Mode

# Build the server
go build -o dashforge-server ./cmd/dashforge-server

# Run with Dolt (local default — connects to a dolt sql-server, creating the
# database if needed; matches the local dolt sql-server ecosystem pattern)
./dashforge-server serve --port 8080 --auto-migrate \
  --db-url 'mysql://root@127.0.0.1:13307/dashforge'

# Or with PostgreSQL (required for Row Level Security / --enable-rls)
export DATABASE_URL="postgres://user:pass@localhost:5432/dashforge?sslmode=disable"
export JWT_SECRET="your-secret-key"

./dashforge-server serve --port 8080 --auto-migrate

Analytics Sources

DashForge connects to multiple analytics sources at once, like Metabase. Sources are added at runtime — via the Data sources panel in the Question builder (/builder/?mode=questions) or the API — and persist across restarts. Only an OmniVault secret reference is stored, never a raw DSN:

# The core engine ships one built-in connector, "sql" — any Postgres,
# MySQL/Dolt, or SQLite database becomes a source through configuration
# alone. Additional connectors (like "roadmap-app" below) are registered by
# the consuming application binary.
export DASHFORGE_WAREHOUSE_DSN='root:@tcp(127.0.0.1:13307)/warehouse'
./dashforge-server serve --address 127.0.0.1:13319

# One-time: register the source (or use the builder UI)
curl -X POST http://127.0.0.1:13319/api/v1/analytics/sources \
  -H 'Content-Type: application/json' \
  -d '{"id":"warehouse","name":"Warehouse","connector":"sql",
       "dsnRef":"env://DASHFORGE_WAREHOUSE_DSN","enabled":true}'

See Analytics Catalog for the catalog model, management API, and credential policy.

Documentation

Full documentation is available at docs/:

• Getting Started
• Dashboard Builder - Visual drag-and-drop editor
• Dashboard IR Reference
• Data Sources - Database connections & providers
• Analytics Catalog - Queryable sources, datasets, fields, and Questions
• Analytics Authorization - GrokifyQL policy with SystemForge and SpiceDB
• Agent Integration - OmniAgent marketplace boundary and DashForge analytics capabilities
• Cube.js Integration - Semantic data layer
• AI Features - LLM-powered dashboard generation
• Server Configuration
• Authentication
• Multi-tenancy
• API Reference

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                        DashForge                                │
├─────────────────────────────────────────────────────────────────┤
│  builder/               Visual dashboard builder (React)        │
│    ├── src/components/  Canvas, widgets, chart builder          │
│    ├── src/ai/          AI generation schemas & prompts         │
│    └── src/api/         DashForge & Cube.js clients             │
├─────────────────────────────────────────────────────────────────┤
│  cube/                  Cube.js semantic layer                  │
│    └── model/cubes/     Data models (YAML)                      │
├─────────────────────────────────────────────────────────────────┤
│  cmd/dashforge/         Static CLI (validate, convert)          │
│  cmd/dashforge-server/  Full server with API                    │
├─────────────────────────────────────────────────────────────────┤
│  dashboardir/           Dashboard JSON schema & types           │
│  viewer/                Embedded static HTML/JS viewer          │
├─────────────────────────────────────────────────────────────────┤
│  datasource/            Plugin-style data source providers      │
│    ├── providers/       PostgreSQL, MySQL implementations       │
│    ├── manager.go       Connection pool management              │
│    └── query.go         Query execution engine                  │
├─────────────────────────────────────────────────────────────────┤
│  internal/server/                                               │
│    ├── api/             REST API handlers                       │
│    ├── analytics/       Queryable source catalog and providers  │
│    ├── auth/            JWT + OAuth (GitHub, Google)            │
│    ├── db/              PostgreSQL with Ent ORM                 │
│    └── middleware/      Tenant context, logging                 │
├─────────────────────────────────────────────────────────────────┤
│  ent/                   Ent schema & generated code             │
│    └── schema/          User, Dashboard, Tenant, etc.           │
└─────────────────────────────────────────────────────────────────┘

Dashboard Builder

The visual builder provides a Metabase-style drag-and-drop interface:

• Widget Palette - Drag charts, metrics, tables, and text onto the canvas
• 12-Column Grid - Responsive layout with snap-to-grid positioning
• Chart Builder - Visual configuration for line, bar, pie, scatter, and area charts
• Query Builder - Connect to Cube.js for semantic queries
• AI Integration - Generate widgets and dashboards from natural language
• Question Builder - Create saved GrokifyQL Questions, browse field values, run results, export CSV/XLSX, and reuse Questions as dashboard widgets

┌─────────────────────────────────────────────────────────────────┐
│                   Dashboard Builder UI                          │
│         (React + TypeScript + react-grid-layout)                │
├─────────────────────────────────────────────────────────────────┤
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────────┐  │
│  │ Widget      │  │ Canvas      │  │ Properties Panel        │  │
│  │ Palette     │  │ (Grid)      │  │ ├── Chart Builder       │  │
│  │ ├── Chart   │  │             │  │ ├── Query Builder       │  │
│  │ ├── Metric  │  │  [Widget]   │  │ └── Style Editor        │  │
│  │ ├── Table   │  │  [Widget]   │  │                         │  │
│  │ └── Text    │  │  [Widget]   │  │                         │  │
│  └─────────────┘  └─────────────┘  └─────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

Dashboard Example

{
  "id": "sales-dashboard",
  "title": "Sales Overview",
  "layout": { "type": "grid", "columns": 12, "rowHeight": 80 },
  "dataSources": [
    {
      "id": "sales",
      "type": "postgres",
      "query": "SELECT date, SUM(amount) as total FROM sales GROUP BY date"
    }
  ],
  "widgets": [
    {
      "id": "revenue-chart",
      "type": "chart",
      "position": { "x": 0, "y": 0, "w": 8, "h": 4 },
      "dataSourceId": "sales",
      "config": {
        "geometry": "line",
        "encodings": { "x": "date", "y": "total" },
        "style": { "smooth": true, "showLegend": true }
      }
    }
  ]
}

Development

# Build all binaries
go build ./...

# Build the dashboard builder
cd builder && npm install && npm run build && cd ..

# Run tests
go test -v ./...

# Lint
golangci-lint run

# Generate Ent code (after schema changes)
go generate ./ent

# Start Cube.js (optional, for semantic queries)
cd cube && npm install && npm run dev

Integration with PipelineConductor

Visualize compliance reports from pipelineconductor:

# Generate compliance data
pipelineconductor check --users plexusone --languages Go -o data/compliance.json

# View in dashboard
open viewer/index.html?dashboard=examples/compliance-dashboard.json

# Or use the visual builder
open http://localhost:8080/builder/

License

MIT