Skip to content

GraphDone v0.3.1-alpha: Enhanced Graph Interaction & Docker Deployment

Latest
Latest

Choose a tag to compare

View all tags
@mvalancy mvalancy released this 08 Sep 03:26
· 1 commit to main since this release
v0.3.1-alpha
f043b87
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

🚀 GraphDone v0.3.1-alpha

A major release featuring enhanced graph interactions, stable camera controls, and production-ready Docker deployment.

✨ What's New

🎯 Enhanced Graph Experience

  • Smart Camera System: Eliminated camera jumps, preserved zoom/pan during updates
  • Intuitive Zoom Controls: Natural scroll behavior (up=zoom in, down=zoom out)
  • Real-time Visual Updates: Immediate feedback for node/edge changes
  • Modern UI Components: Refreshed modals, hover effects, and animations

🔒 Production Infrastructure

  • Secure Docker Setup: Internal networking, security hardening, health monitoring
  • SQLite Authentication: Encrypted passwords, session management
  • Enhanced Admin Tools: Database management, health diagnostics, cleanup utilities
  • Reliable CI/CD: Automated testing and deployment pipeline

🏗️ System Architecture

┌─────────────────────────────────────────────────────────────────┐
│                        GRAPHDONE SYSTEM                        │
├─────────────────────────────────────────────────────────────────┤
│  Frontend Layer (Port 3127)                                    │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────┐   │
│  │   React     │ │   D3.js     │ │   Apollo Client         │   │
│  │   Web App   │ │   Graph     │ │   GraphQL + WebSocket   │   │
│  └─────────────┘ └─────────────┘ └─────────────────────────┘   │
├─────────────────────────────────────────────────────────────────┤
│  API Layer (Port 4127)                                         │
│  ┌─────────────────────────┐ ┌─────────────────────────────────┐│
│  │   GraphQL API Server    │ │   SQLite Authentication        ││
│  │   Apollo + Express      │ │   bcrypt + session management  ││
│  └─────────────────────────┘ └─────────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│  Data Layer (Internal Network)                                 │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────────┐│
│  │   Neo4j     │ │   Redis     │ │   SQLite                    ││
│  │   Graph DB  │ │   Cache     │ │   User Auth                 ││
│  │   APOC+GDS  │ │   Sessions  │ │   File Storage              ││
│  └─────────────┘ └─────────────┘ └─────────────────────────────┘│
├─────────────────────────────────────────────────────────────────┤
│  Infrastructure Layer                                          │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────────────────────┐│
│  │   Docker    │ │   Health    │ │   Security                  ││
│  │   Compose   │ │   Monitor   │ │   Non-root + Cap Dropping   ││
│  └─────────────┘ └─────────────┘ └─────────────────────────────┘│
└─────────────────────────────────────────────────────────────────┘

🔄 Real-time Graph Updates Flow

User Action → Web UI → GraphQL API → Neo4j Database
     ↓           ↓           ↓            ↓
 Click Node   Send Mutation  Execute      Update
   Edit         Request      Cypher       Graph
     ↓           ↓           ↓            ↓
 UI Update ← Response ← Query Result ← Database
     ↓
Smart Update Check:
  ├─ Data Structure Changed? → Full Reinitialization (Camera Preserved)
  └─ Properties Only? → Gentle Simulation Update

Result: Real-time visual feedback with stable camera position

🐳 Docker Deployment Structure

Host System (localhost:3127)
     │
     └── Docker Internal Network (bridge)
         ├── graphdone-web (React App)
         │   ├── Vite Dev Server
         │   ├── Security: non-root user (1001:1001)
         │   └── Health Check: curl localhost:3127
         │
         ├── graphdone-api (GraphQL Server)
         │   ├── Apollo Server + Express
         │   ├── Security: non-root user (1001:1001)
         │   └── Health Check: curl localhost:4127/health
         │
         ├── graphdone-neo4j (Graph Database)
         │   ├── Neo4j 5.26 + APOC + GDS
         │   ├── Security: capability dropping, no external ports
         │   └── Health Check: cypher-shell connection test
         │
         └── graphdone-redis (Cache & Sessions)
             ├── Redis 8 Alpine
             ├── Security: read-only filesystem, user 999:999
             └── Health Check: redis-cli ping

Security Features Applied to All Containers:
• no-new-privileges:true
• Capability dropping (ALL removed, selective add)
• Internal networking only (except web UI)
• Health monitoring and auto-restart
• Centralized logging to volumes

🔐 Authentication & Security

Password Security

  • bcrypt encryption with salt rounds for all user passwords
  • Session-based authentication with secure HTTP-only cookies
  • JWT tokens for API authentication
  • SQLite database for user storage (production-ready)

Container Security

  • Non-root users in all containers (UIDs 999-1001)
  • Capability dropping - remove ALL, add only necessary capabilities
  • Read-only filesystems where possible (Redis)
  • Internal networking - only web UI exposed to host
  • Security scanning in CI pipeline

Network Security

  • Internal Docker network isolates services
  • No external database ports (7687, 6379 internal only)
  • Single entry point through web UI (port 3127)
  • Health checks ensure service availability

🐳 Quick Start with Docker

Prerequisites

  • Docker & Docker Compose installed
  • Git for cloning the repository

One-Command Setup

git clone https://github.com/GraphDone/GraphDone-Core.git
cd GraphDone-Core
./start

That's it! The ./start script will:

  1. Set up the complete Docker environment
  2. Build all services with security hardening
  3. Launch GraphDone at http://localhost:3127

What Gets Deployed

  • Web Application: React frontend with graph visualization
  • GraphQL API: Node.js backend with real-time subscriptions
  • Neo4j Database: Graph database with APOC/GDS plugins
  • Redis Cache: Session storage and caching
  • Security: Internal networking, non-root containers, health monitoring

Default Setup

  • Create your account through the signup flow
  • All data persists in Docker volumes
  • Admin tools available at /admin after login

🛠 Development Mode

For development with hot reloading:

./start --dev
# or
./tools/run.sh --docker-dev

🔧 Manual Setup (Advanced)

If you prefer manual control:

# 1. Environment Setup
./tools/setup.sh

# 2. Start Services
docker-compose -f deployment/docker-compose.dev.yml up -d

# 3. Access Application
open http://localhost:3127

📊 System Requirements

Minimum

  • CPU: 2 cores
  • RAM: 4GB
  • Disk: 2GB free space
  • Ports: 3127 (web), 7474/7687 (Neo4j internal)

Recommended

  • CPU: 4+ cores
  • RAM: 8GB+
  • Disk: 10GB+ for data growth
  • Network: Fast connection for real-time features

🔍 Health Monitoring

Check system status:

# Container health
docker ps

# Application health
curl http://localhost:3127/health

# Access admin dashboard
# Navigate to http://localhost:3127/admin

🚧 Next Release Roadmap

v0.3.1-alpha (Current)     v0.4.0-alpha (Next)        v0.5.0+ (Future)
├── Graph Interactions     ├── Enhanced Node Editing   ├── TLS/SSL Security
├── Docker Security        ├── Inline Connections      ├── Production Deploy
├── CI/CD Pipeline        ├── Streamlined UX          ├── AI Mini-Agents
└── Camera Stability      └── Real-time Collaboration └── In-App Documentation

Timeline: Q1 2025          Timeline: Q2 2025           Timeline: Q3-Q4 2025

Immediate Next Steps (v0.4.0-alpha)

  1. Enhanced Node Editing: Streamlined creation and connection workflows
  2. TLS/SSL Security: Production-grade encrypted connections
  3. AI Agent Integration: Mini-agents for intelligent graph assistance
  4. In-App Documentation: Interactive help with detailed diagrams

📋 Technical Stack Details

Frontend Technologies

  • React 18 + TypeScript for modern UI development
  • D3.js for interactive graph visualization with force simulation
  • Tailwind CSS for consistent styling and responsive design
  • Apollo Client for GraphQL integration with real-time subscriptions
  • Vite for fast development and optimized builds

Backend Technologies

  • Node.js + TypeScript for server-side development
  • Apollo Server for GraphQL API with subscription support
  • Express.js for HTTP server and middleware
  • SQLite for authentication and user management
  • bcrypt for secure password hashing

Database & Storage

  • Neo4j 5.26 graph database with APOC and Graph Data Science plugins
  • Redis 8 for session storage and application caching
  • SQLite for user authentication and metadata
  • Docker Volumes for persistent data storage

DevOps & Infrastructure

  • Docker Compose for multi-container orchestration
  • GitHub Actions for CI/CD pipeline
  • Playwright for end-to-end testing
  • Vitest for unit testing
  • ESLint + TypeScript for code quality

🐛 Issues & Support

Report issues at: https://github.com/GraphDone/GraphDone-Core/issues

For quick support:

  1. Check docker ps for container health
  2. Visit /admin for system diagnostics
  3. Review logs with docker logs <container-name>

Common Troubleshooting

  • Port conflicts: Ensure ports 3127, 4127, 7687, 6379 are available
  • Docker issues: Try docker system prune to clean up resources
  • Database connection: Check Neo4j health at http://localhost:7474
  • Authentication problems: Clear browser cookies and try again

Ready to reimagine project management? Run ./start and explore graph-native coordination! 🌟

Assets 2
Loading