fix: pre-seed databases at build time, show loading screen on startup

MoonMao42 · MoonMao42 · commit 204577db6ef5 · 2026-03-24T07:48:18.000+08:00
Build generates demo.db and querygpt.db with sample data already in
place. First launch just copies them over instead of running init logic
every time. Also stops re-creating demo connections/terms that users
already deleted. Loading spinner shows immediately so startup doesn't
feel like it's hanging.
diff --git a/apps/api/app/core/demo_db.py b/apps/api/app/core/demo_db.py
@@ -4,6 +4,7 @@
 用于演示 QueryGPT 的查询和可视化功能。
 """
 
+import os
 import random
 import sqlite3
 from datetime import datetime, timedelta
@@ -13,13 +14,17 @@
 from sqlalchemy import select, update
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.db.tables import Connection, SemanticTerm
-from app.services.app_settings import get_or_create_app_settings
+from app.db.tables import Connection
 
 logger = structlog.get_logger()
 
-# 示例数据库路径
-DEMO_DB_PATH = Path(__file__).parent.parent.parent / "data" / "demo.db"
+# 示例数据库路径：优先用 DATA_DIR 环境变量（桌面版），否则用源码相对路径
+_data_dir = os.environ.get("DATA_DIR")
+if _data_dir:
+    DEMO_DB_PATH = Path(_data_dir) / "demo.db"
+else:
+    DEMO_DB_PATH = Path(__file__).parent.parent.parent / "data" / "demo.db"
+
 DEMO_CONNECTION_NAME = "Sample Database"
 
 # 产品数据
@@ -119,133 +124,21 @@ def init_demo_database() -> str:
     return get_demo_db_path()
 
 
-async def ensure_demo_connection(db: AsyncSession, demo_db_path: str) -> None:
-    """在单工作区没有任何连接时，自动补一条示例数据库连接"""
-    # Migrate old Chinese name to English
-    old_demo = await db.scalar(select(Connection.id).where(Connection.name == "示例数据库"))
-    if old_demo:
-        await db.execute(
-            update(Connection)
-            .where(Connection.name == "示例数据库")
-            .values(name=DEMO_CONNECTION_NAME)
-        )
-        await db.commit()
-        logger.info("Migrated demo connection name to English")
-        return
-
-    has_connections = await db.scalar(select(Connection.id).limit(1))
-    if has_connections is not None:
-        return
-
-    connection = Connection(
-        name=DEMO_CONNECTION_NAME,
-        driver="sqlite",
-        host=None,
-        port=None,
-        username=None,
-        password_encrypted=None,
-        database_name=demo_db_path,
-        extra_options={},
-        is_default=True,
-    )
-    db.add(connection)
-    await db.flush()
-
-    settings_record = await get_or_create_app_settings(db)
-    settings_record.default_connection_id = connection.id
-    await db.flush()
-
-    logger.info("Seeded demo connection", name=DEMO_CONNECTION_NAME, database=demo_db_path)
-
-
-# Demo semantic terms (English)
-DEMO_SEMANTIC_TERMS = [
-    {
-        "term": "GMV",
-        "expression": "SUM(sales.quantity * sales.unit_price)",
-        "term_type": "metric",
-        "description": "Gross Merchandise Value — total sales revenue (quantity × unit price)",
-        "examples": ["What is this month's GMV?", "GMV by region"],
-    },
-    {
-        "term": "Top Customers",
-        "expression": "customers.id IN (SELECT customer_id FROM sales GROUP BY customer_id HAVING SUM(amount) > 100000)",
-        "term_type": "filter",
-        "description": "Customers with cumulative spending over 100,000",
-        "examples": ["List all top customers", "Top customers by region"],
-    },
-    {
-        "term": "Average Order Value",
-        "expression": "AVG(sales.amount)",
-        "term_type": "metric",
-        "description": "Average transaction amount per sale",
-        "examples": ["What is the average order value?", "AOV trend over the past 6 months"],
-    },
-]
-
-# Old Chinese term names to migrate
-_CHINESE_TERM_NAMES = {"GMV", "大客户", "客单价"}
-
-
-async def ensure_demo_semantic_terms(db: AsyncSession, connection_id) -> None:
-    """Seed demo semantic terms or migrate old Chinese ones to English."""
-    from sqlalchemy import func
-
-    # Check for old Chinese terms and remove them (will be replaced by English ones)
-    old_chinese = await db.scalars(
-        select(SemanticTerm.id).where(SemanticTerm.term.in_(["大客户", "客单价"]))
-    )
-    old_ids = list(old_chinese)
-
-    # Also check for GMV with Chinese description
-    gmv_term = await db.scalar(
-        select(SemanticTerm.id).where(
-            SemanticTerm.term == "GMV",
-            SemanticTerm.description.like("%商品交易%"),
+async def fix_demo_db_path(db: AsyncSession, demo_db_path: str) -> None:
+    """修正预打包数据库中的占位符路径为实际的 demo.db 绝对路径"""
+    result = await db.scalar(
+        select(Connection.id).where(
+            Connection.name == DEMO_CONNECTION_NAME,
+            Connection.database_name == "__DEMO_DB_PATH__",
         )
     )
-    if gmv_term:
-        old_ids.append(gmv_term)
-
-    if old_ids:
-        from sqlalchemy import delete
-
-        await db.execute(delete(SemanticTerm).where(SemanticTerm.id.in_(old_ids)))
-        logger.info("Removed old Chinese semantic terms", count=len(old_ids))
-
-    # Check if English demo terms already exist
-    existing_count = await db.scalar(
-        select(func.count())
-        .select_from(SemanticTerm)
-        .where(SemanticTerm.term.in_([t["term"] for t in DEMO_SEMANTIC_TERMS]))
-    )
-    if existing_count and existing_count >= len(DEMO_SEMANTIC_TERMS):
-        return
-
-    # Seed missing English demo terms
-    existing_names = set(
-        await db.scalars(
-            select(SemanticTerm.term).where(
-                SemanticTerm.term.in_([t["term"] for t in DEMO_SEMANTIC_TERMS])
-            )
-        )
-    )
-    for term_data in DEMO_SEMANTIC_TERMS:
-        if term_data["term"] in existing_names:
-            continue
-        term = SemanticTerm(
-            connection_id=connection_id,
-            term=term_data["term"],
-            expression=term_data["expression"],
-            term_type=term_data["term_type"],
-            description=term_data["description"],
-            examples=term_data["examples"],
-            is_active=True,
+    if result is not None:
+        await db.execute(
+            update(Connection)
+            .where(Connection.database_name == "__DEMO_DB_PATH__")
+            .values(database_name=demo_db_path)
         )
-        db.add(term)
-
-    await db.flush()
-    logger.info("Seeded demo semantic terms")
+        logger.info("Fixed demo connection path", path=demo_db_path)
 
 
 def _create_tables(cursor: sqlite3.Cursor) -> None:
diff --git a/apps/api/app/db/tables.py b/apps/api/app/db/tables.py
@@ -98,6 +98,7 @@ class AppSettings(Base, TimestampMixin):
     python_enabled: Mapped[bool] = mapped_column(Boolean, default=True)
     diagnostics_enabled: Mapped[bool] = mapped_column(Boolean, default=True)
     auto_repair_enabled: Mapped[bool] = mapped_column(Boolean, default=True)
+    demo_initialized: Mapped[bool] = mapped_column(Boolean, default=False)
 
 
 class SemanticTerm(Base, UUIDMixin, TimestampMixin):
diff --git a/apps/api/app/main.py b/apps/api/app/main.py
@@ -17,7 +17,7 @@
 
 from app.api.v1 import api_router
 from app.core.config import settings
-from app.core.demo_db import ensure_demo_connection, ensure_demo_semantic_terms, init_demo_database
+from app.core.demo_db import fix_demo_db_path, init_demo_database
 from app.db import AsyncSessionLocal, engine
 from app.db.base import Base
 
@@ -67,22 +67,12 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]:
             await conn.run_sync(Base.metadata.create_all)
         logger.info("Database tables created")
 
-    # 初始化示例数据库
+    # 确保 demo.db 存在（构建时已预生成，这里只是 fallback）
     demo_db_path = init_demo_database()
-    logger.info("Demo database initialized", path=demo_db_path)
 
+    # 修正预打包数据库中的占位符路径
     async with AsyncSessionLocal() as session:
-        await ensure_demo_connection(session, demo_db_path)
-        # Seed semantic layer demo terms (needs connection_id)
-        from sqlalchemy import select as sa_select
-
-        from app.db.tables import Connection
-
-        demo_conn_id = await session.scalar(
-            sa_select(Connection.id).where(Connection.name == "Sample Database")
-        )
-        if demo_conn_id:
-            await ensure_demo_semantic_terms(session, demo_conn_id)
+        await fix_demo_db_path(session, demo_db_path)
         await session.commit()
 
     yield
diff --git a/apps/desktop/electron/main.ts b/apps/desktop/electron/main.ts
@@ -10,26 +10,58 @@ let processManager: ProcessManager;
 
 const isDev = process.env.NODE_ENV === 'development';
 
+const LOADING_HTML = `data:text/html;charset=utf-8,${encodeURIComponent(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><style>
+  body { margin:0; height:100vh; display:flex; align-items:center; justify-content:center;
+         background:#0f0f1a; color:#e0e0e0; font-family:system-ui,-apple-system,sans-serif; }
+  .wrap { text-align:center; }
+  .spinner { width:40px; height:40px; margin:0 auto 24px; border:3px solid #333;
+             border-top-color:#6366f1; border-radius:50%; animation:spin .8s linear infinite; }
+  @keyframes spin { to { transform:rotate(360deg); } }
+  h2 { font-size:18px; font-weight:500; margin:0 0 8px; }
+  p { font-size:13px; color:#888; margin:0; }
+</style></head><body>
+<div class="wrap">
+  <div class="spinner"></div>
+  <h2>QueryGPT</h2>
+  <p>Starting services...</p>
+</div>
+</body></html>`)}`;
+
+const ERROR_HTML = (error: unknown) =>
+  `data:text/html;charset=utf-8,${encodeURIComponent(`<!DOCTYPE html>
+<html><head><meta charset="utf-8"><style>
+  body { margin:0; padding:40px; background:#0f0f1a; color:#e0e0e0; font-family:system-ui; }
+  code { color:#ff6b6b; display:block; margin:12px 0; white-space:pre-wrap; }
+  p { color:#888; }
+</style></head><body>
+<h1>QueryGPT failed to start</h1>
+<p>Check the logs for details:</p>
+<code>${String(error)}</code>
+<p>Logs: ~/.querygpt-desktop/logs/</p>
+</body></html>`)}`;
+
 async function createWindow(): Promise<BrowserWindow> {
   const win = new BrowserWindow({
     width: 1280,
     height: 800,
     minWidth: 900,
     minHeight: 600,
-    title: '',
+    title: 'QueryGPT',
     webPreferences: {
       preload: path.join(__dirname, 'preload.js'),
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
     },
     show: false,
+    backgroundColor: '#0f0f1a',
   });
 
-  win.once('ready-to-show', () => {
-    win.show();
-    logger.info('Main window shown');
-  });
+  // 立即显示 loading 页面
+  await win.loadURL(LOADING_HTML);
+  win.show();
+  logger.info('Loading screen shown');
 
   return win;
 }
@@ -50,15 +82,7 @@ app.whenReady().then(async () => {
     logger.info(`Frontend loaded: ${frontendUrl}`);
   } catch (error) {
     logger.error('Failed to start services', error);
-    // 显示错误页面而不是直接退出
-    mainWindow.show();
-    mainWindow.loadURL(`data:text/html,
-      <html><body style="font-family:system-ui;padding:40px;background:#1a1a2e;color:#eee">
-      <h1>QueryGPT failed to start</h1>
-      <p>Check the logs for details:</p>
-      <code style="color:#ff6b6b">${String(error).replace(/</g,'&lt;')}</code>
-      <p style="margin-top:20px;color:#888">Logs: ~/.querygpt-desktop/logs/</p>
-      </body></html>`);
+    await mainWindow.loadURL(ERROR_HTML(error));
   }
 
   app.on('activate', async () => {
diff --git a/apps/desktop/electron/process-manager.ts b/apps/desktop/electron/process-manager.ts
@@ -62,7 +62,7 @@ export class ProcessManager {
       } else {
         cmd = `lsof -ti tcp:${port}`;
       }
-      const result = execSync(cmd, { encoding: 'utf-8' }).trim();
+      const result = execSync(cmd, { encoding: 'utf-8', timeout: 3000 }).trim();
       if (result) {
         for (const pid of result.split('\n')) {
           const p = parseInt(pid.trim());
@@ -81,6 +81,24 @@ export class ProcessManager {
     } catch { /* no process on port */ }
   }
 
+  /** 首次启动时从打包资源复制预生成的数据库到用户数据目录 */
+  private copyBundledDatabases(): void {
+    const dataDir = path.join(this.userDataDir, 'data');
+    // 打包资源中的 data/ 目录（由 PyInstaller 打包进 backend/_internal/data/）
+    const bundledDataDir = path.join(this.getBackendOutDir(), '_internal', 'data');
+
+    for (const dbName of ['demo.db', 'querygpt.db']) {
+      const dest = path.join(dataDir, dbName);
+      if (fs.existsSync(dest)) continue;
+
+      const src = path.join(bundledDataDir, dbName);
+      if (fs.existsSync(src)) {
+        fs.copyFileSync(src, dest);
+        this.logger.info(`Copied bundled ${dbName} to user data dir`);
+      }
+    }
+  }
+
   async startAll(): Promise<void> {
     fs.mkdirSync(this.userDataDir, { recursive: true });
     fs.mkdirSync(path.join(this.userDataDir, 'logs'), { recursive: true });
@@ -93,6 +111,9 @@ export class ProcessManager {
       this.logger.info('Created user .env from example');
     }
 
+    // 首次启动：从打包资源复制预生成的数据库到用户目录
+    this.copyBundledDatabases();
+
     // 清理可能残留的旧进程
     this.killPortProcess(BACKEND_PORT);
     this.killPortProcess(FRONTEND_PORT);
diff --git a/apps/desktop/scripts/build-pyinstaller.ts b/apps/desktop/scripts/build-pyinstaller.ts
@@ -111,6 +111,11 @@ async function main() {
   // 显式安装 aiosqlite（pydantic-settings 动态加载时需要）
   run(`${pip} install aiosqlite`);
 
+  // 2.5. 预生成 demo.db + querygpt.db（构建时生成，运行时直接复制到用户目录）
+  console.log('\nPre-generating databases...');
+  const seedScript = join(DESKTOP_DIR, 'scripts', 'seed-databases.py');
+  run(`${python} "${seedScript}"`);
+
   // 3. 收集可能动态导入的模块
   console.log('\n[3/5] Collecting dynamic imports...');
   const hiddenImports = [
diff --git a/apps/desktop/scripts/seed-databases.py b/apps/desktop/scripts/seed-databases.py
