graphxr-database-proxy 1.0.0__py3-none-any.whl

graphxr_database_proxy/main.py

@@ -0,0 +1,110 @@
+"""
+Main FastAPI application
+"""
+
+import os
+import uvicorn
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+
+from .api.projects import router as projects_router
+from .api.database import router as database_router
+from .api.google import router as google_router
+
+# Create FastAPI app
+app = FastAPI(
+    title="GraphXR Database Proxy",
+    description="Secure middleware for connecting GraphXR to databases",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc"
+)
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Configure this for production
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Include API routers
+app.include_router(projects_router)
+app.include_router(database_router)
+app.include_router(google_router)
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    return {
+        "status": "healthy", 
+        "message": "GraphXR Database Proxy is running",
+        "version": "1.0.0",
+        "environment": "development",
+        "auto_reload": "enabled"
+    }
+
+# Mount static files from package
+static_dir = Path(__file__).parent / "static"
+frontend_dist = Path(__file__).parent.parent.parent / "frontend" / "dist"
+ 
+if static_dir.exists() or frontend_dist.exists():
+    static_dir = frontend_dist if frontend_dist.exists() else static_dir
+    print(f"🔧 Serving static files from: {static_dir}")
+    # Development: Use frontend dist directory
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+    
+    @app.get("/{full_path:path}")
+    async def serve_frontend(full_path: str):
+        """Serve the frontend application for all unmatched paths"""
+        index_file = static_dir / "index.html"
+        if index_file.exists():
+            return FileResponse(str(index_file))
+        return {"message": "Frontend not available"}
+        
+else:
+    @app.get("/")
+    async def serve_fallback():
+        """Fallback when frontend is not built"""
+        return {
+            "message": "Frontend not available", 
+            "hint": "Run 'python scripts/build_frontend.py' to build and package frontend"
+        }
+
+
+def main():
+    """Main entry point"""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="GraphXR Database Proxy")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to")
+    parser.add_argument("--port", type=int, default=9080, help="Port to bind to")
+    parser.add_argument("--ui", action="store_true", help="Enable UI mode")
+    parser.add_argument("--dev", action="store_true", help="Development mode with hot reload")
+    
+    args = parser.parse_args()
+    
+    # Configure logging
+    import logging
+    logging.basicConfig(
+        level=logging.INFO,
+        format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    
+    # Run the server
+    uvicorn.run(
+        "src.graphxr_database_proxy.main:app",
+        host=args.host,
+        port=args.port,
+        reload=args.dev,
+        log_level="info" if not args.dev else "debug"
+    )
+
+
+if __name__ == "__main__":
+    main()

graphxr_database_proxy/models/__init__.py

@@ -0,0 +1 @@
+# Models package

graphxr_database_proxy/models/google.py

@@ -0,0 +1,50 @@
+"""
+Google Cloud API models
+"""
+
+from typing import Dict, Any, List, Optional
+from pydantic import BaseModel
+
+
+class GoogleAuthInfo(BaseModel):
+    """Google authentication information"""
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    project_id: Optional[str] = None
+    instance_id: Optional[str] = None
+    database_id: Optional[str] = None
+    graph_name: Optional[str] = None
+    
+     
+class GoogleProject(BaseModel):
+    """Google Cloud project information"""
+    name: str
+    id: str
+    instances:  List[Any] = []
+
+class GraphDatabase(BaseModel):
+    """Graph database information"""
+    id: str
+    name: str
+
+
+class SpannerDatabase(BaseModel):
+    """Spanner database information"""
+    id: str
+    name: str
+    graphDBs: List[GraphDatabase] = []
+
+
+class SpannerInstance(BaseModel):
+    """Spanner instance information"""
+    id: str
+    name: str
+    databases: List[SpannerDatabase] = []
+
+
+class ProjectDetails(BaseModel):
+    """Project details with instances and databases"""
+    # Key is instance_id, value is instance details
+    instances: List[SpannerInstance] = []

graphxr_database_proxy/models/project.py

@@ -0,0 +1,170 @@
+"""
+Data models for the GraphXR Database Proxy
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Literal
+from pydantic import BaseModel, Field
+from enum import Enum
+
+
+class DatabaseType(str, Enum):
+    """Supported database types"""
+    SPANNER = "spanner"
+    POSTGRESQL = "postgresql"
+    MYSQL = "mysql"
+    MONGODB = "mongodb"
+
+
+class AuthType(str, Enum):
+    """Authentication types"""
+    OAUTH2 = "oauth2"
+    SERVICE_ACCOUNT = "service_account"
+    USERNAME_PASSWORD = "username_password"
+
+
+class OAuthConfig(BaseModel):
+    """OAuth2 configuration"""
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    redirect_uri: str = "http://localhost:9080/google/spanner/callback"
+    scopes: List[str] = Field(default_factory=list)
+    
+    # For OAuth2 token-based auth
+    token: Optional[str] = None
+    refresh_token: Optional[str] = None
+    expires_in: Optional[int] = None
+    last_refreshed: Optional[float] = None  # Unix timestamp of last token refresh
+    token_uri: Optional[str] = None
+
+    # For Service Account JSON key
+    type: Optional[str] = None
+    project_id: Optional[str] = None
+    private_key_id: Optional[str] = None
+    private_key: Optional[str] = None
+    client_email: Optional[str] = None
+    client_x509_cert_url: Optional[str] = None
+    auth_uri: Optional[str] = None
+    auth_provider_x509_cert_url: Optional[str] = None
+    
+    # Allow additional fields for flexibility
+    class Config:
+        extra = "allow"
+
+
+class DatabaseConfig(BaseModel):
+    """Database connection configuration"""
+    # Common fields
+    type: DatabaseType
+    host: Optional[str] = None
+    port: Optional[int] = None
+    
+    # Spanner specific
+    project_id: Optional[str] = None
+    instance_id: Optional[str] = None
+    database_id: Optional[str] = None
+    graph_name: Optional[str] = None
+    
+    # Authentication
+    auth_type: AuthType = AuthType.USERNAME_PASSWORD
+    username: Optional[str] = None
+    password: Optional[str] = None
+    oauth_config: Optional[OAuthConfig] = None
+    service_account_path: Optional[str] = None  # For backward compatibility
+    # Additional options
+    options: Dict[str, Any] = Field(default_factory=dict)
+
+
+class Project(BaseModel):
+    """Project model"""
+    id: str = Field(..., description="Unique project identifier")
+    name: str = Field(..., description="Project name (should be unique)")
+    database_type: DatabaseType = Field(..., description="Database type")
+    database_config: DatabaseConfig = Field(..., description="Database configuration")
+    create_time: datetime = Field(default_factory=datetime.utcnow)
+    update_time: datetime = Field(default_factory=datetime.utcnow)
+    
+    class Config:
+        json_encoders = {
+            datetime: lambda v: v.isoformat()
+        }
+
+
+class ProjectCreate(BaseModel):
+    """Project creation request"""
+    name: str = Field(..., description="Project name")
+    database_type: DatabaseType = Field(..., description="Database type")
+    database_config: DatabaseConfig = Field(..., description="Database configuration")
+
+
+class ProjectUpdate(BaseModel):
+    """Project update request"""
+    name: Optional[str] = None
+    database_config: Optional[DatabaseConfig] = None
+
+
+class APIInfo(BaseModel):
+    """Database API information"""
+    type: DatabaseType
+    api_urls: Dict[str, str]
+    version: Optional[str] = None
+
+
+class QueryRequest(BaseModel):
+    """Database query request"""
+    query: str = Field(..., description="Query string")
+    parameters: Dict[str, Any] = Field(default_factory=dict, description="Query parameters")
+
+
+class QueryResponse(BaseModel):
+    """Database query response"""
+    success: bool
+    data: Optional[Any] = None
+    error: Optional[str] = None
+    execution_time: Optional[float] = None
+
+
+class SchemaResponse(BaseModel):
+    """Database schema response"""
+    success: bool
+    data: Optional[Dict[str, Dict[str, str]]] = None
+    error: Optional[str] = None
+
+class Category(BaseModel):
+    name: str
+    props: Optional[List[str]] = None
+    keys: Optional[List[str]] = None
+    propsTypes: Optional[Dict[str, str]] = None
+
+class Relationship(BaseModel):
+    name: str
+    props: Optional[List[str]] = None
+    keys: Optional[List[str]] = None
+    propsTypes: Optional[Dict[str, str]] = None
+    startCategory: str
+    endCategory: str
+
+class GraphSchema(BaseModel):
+    categories: List[Category] 
+    relationships: List[Relationship]
+
+class GraphSchemaResponse(BaseModel):
+    """Graph database schema response"""
+    success: bool
+    data: GraphSchema = Field(default_factory=lambda: GraphSchema(categories=[], relationships=[]))
+    error: Optional[str] = None
+
+class SampleDataResponse(BaseModel):
+    """Sample data response"""
+    success: bool
+    data: Optional[Dict[str, Any]] = None
+    error: Optional[str] = None
+
+class GraphData(BaseModel):
+    nodes: List[Dict[str, Any]] = Field(default_factory=list)
+    relationships: List[Dict[str, Any]] = Field(default_factory=list)
+
+class QueryData(BaseModel):
+    type: Literal["TABLE", "GRAPH"]
+    data:  List[Dict[str, Any]] | GraphData | None = None
+    summary: Dict[str, str] = Field(default_factory=lambda: {"version": "4.0.1"})