🚀 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:

Set up the complete Docker environment
Build all services with security hardening
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)

🔍 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)

Enhanced Node Editing: Streamlined creation and connection workflows
TLS/SSL Security: Production-grade encrypted connections
AI Agent Integration: Mini-agents for intelligent graph assistance
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:

Check docker ps for container health
Visit /admin for system diagnostics
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! 🌟

Releases: GraphDone/GraphDone-Core

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