@dangao/bun-server 3.0.0 → 3.0.1

package/dist/index.node.mjs

@@ -10932,8 +10932,8 @@ class ConnectionPool {
       const { Database } = await import("bun:sqlite");
       return new Database(config.path);
     }
-    const BetterSqlite3 = __require("better-sqlite3");
-    return BetterSqlite3(config.path);
+    const sqlite3 = __require("@vscode/sqlite3");
+    return new sqlite3.Database(config.path);
   }
   async createPostgresConnection(config) {
     const url = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
@@ -11099,11 +11099,25 @@ class DatabaseConnectionManager {
   }
   async healthCheckSqlite(connection) {
     try {
-      if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
+      if (!connection || typeof connection !== "object") {
+        return false;
+      }
+      if ("query" in connection && typeof connection.query === "function" && !(("all" in connection) && ("run" in connection))) {
         const db = connection;
         db.query("SELECT 1").all();
         return true;
       }
+      if ("all" in connection && typeof connection.all === "function") {
+        await new Promise((resolve2, reject) => {
+          connection.all("SELECT 1", [], (err) => {
+            if (err)
+              reject(err);
+            else
+              resolve2();
+          });
+        });
+        return true;
+      }
       return false;
     } catch (_error) {
       return false;
@@ -11213,12 +11227,22 @@ class DatabaseService2 {
     throw new Error(`Query not supported for database type: ${dbType}`);
   }
   querySqlite(connection, sql, params) {
-    if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
+    if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function" && !(("all" in connection) && ("run" in connection))) {
       const db = connection;
       const statement = db.query(sql);
       const result = params && params.length > 0 ? statement.all(...params) : statement.all();
       return result;
     }
+    if (connection && typeof connection === "object" && "all" in connection && typeof connection.all === "function") {
+      return new Promise((resolve2, reject) => {
+        connection.all(sql, params ?? [], (err, rows) => {
+          if (err)
+            reject(err);
+          else
+            resolve2(rows ?? []);
+        });
+      });
+    }
     throw new Error("Invalid SQLite connection");
   }
   async queryBunSQL(connection, sql, params) {
@@ -11389,24 +11413,29 @@ class SqliteAdapter {
       }
       this.db = db;
     } else {
-      const BetterSqlite3 = __require("better-sqlite3");
-      const db = BetterSqlite3(config.database);
+      const sqlite3 = __require("@vscode/sqlite3");
+      const db = new sqlite3.Database(config.database);
       if (config.wal !== false) {
-        db.exec("PRAGMA journal_mode = WAL;");
+        db.run("PRAGMA journal_mode = WAL;");
       }
       this.db = db;
     }
     this.semaphore = new Semaphore(config.maxWriteConcurrency ?? 1);
   }
-  query(sql, params = []) {
+  async query(sql, params = []) {
     if (this.isBun) {
-      const db2 = this.db;
-      const stmt2 = db2.query(sql);
-      return stmt2.all(...params);
+      const db = this.db;
+      const stmt = db.query(sql);
+      return stmt.all(...params);
     }
-    const db = this.db;
-    const stmt = db.prepare(sql);
-    return stmt.all(...params);
+    return new Promise((resolve2, reject) => {
+      this.db.all(sql, params, (err, rows) => {
+        if (err)
+          reject(err);
+        else
+          resolve2(rows ?? []);
+      });
+    });
   }
   async execute(sql, params = []) {
     if (this.isBun) {
@@ -11414,9 +11443,14 @@ class SqliteAdapter {
       const stmt = db.query(sql);
       stmt.run(...params);
     } else {
-      const db = this.db;
-      const stmt = db.prepare(sql);
-      stmt.run(...params);
+      return new Promise((resolve2, reject) => {
+        this.db.run(sql, params, (err) => {
+          if (err)
+            reject(err);
+          else
+            resolve2();
+        });
+      });
     }
   }
   close() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dangao/bun-server",
-  "version": "3.0.0",
+  "version": "3.0.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -50,7 +50,7 @@
     "test:platform": "bun run test:bun && bun run test:node",
     "type-check": "tsc --noEmit",
     "clean": "rm -rf dist",
-    "bundle": "bun build src/index.ts --target=bun --format=esm --outfile=dist/index.js --external reflect-metadata --external @dangao/logsmith --external @dangao/nacos-client",
+    "bundle": "bun build src/index.ts --target=bun --format=esm --outfile=dist/index.js --external reflect-metadata --external @dangao/logsmith --external @dangao/nacos-client --external @vscode/sqlite3",
     "bundle:node": "bun build src/index.ts --target=node --packages=external --outfile=dist/index.node.mjs",
     "dts": "tsc -p tsconfig.build.json",
     "build": "bun run clean && bun run bundle && bun run bundle:node && bun run dts",
@@ -59,7 +59,6 @@
     "publish:package:github": "cp -r ../../README.md ../../LICENSE ../../docs . && bun pm pack --access public && npm publish *.tgz --provenance --access public && rm -rf ./README.md ./LICENSE ./docs"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.6.13",
     "@types/bun": "^1.3.10",
     "@types/mime-types": "^3.0.1",
     "@types/ws": "^8.18.1",
@@ -69,7 +68,7 @@
   "dependencies": {
     "@dangao/logsmith": "0.2.0",
     "@dangao/nacos-client": "0.1.1",
-    "better-sqlite3": "^12.8.0",
+    "@vscode/sqlite3": "5.1.12-vscode",
     "json5": "^2.2.3",
     "jsonc-parser": "^3.3.1",
     "marked": "^18.0.0",

package/src/database/connection-manager.ts

@@ -160,21 +160,28 @@ export class DatabaseConnectionManager {
    */
   private async healthCheckSqlite(connection: unknown): Promise<boolean> {
     try {
-      if (
-        connection &&
-        typeof connection === 'object' &&
-        'query' in connection &&
-        typeof connection.query === 'function'
-      ) {
-        // 执行简单的查询来检查连接
-        const db = connection as {
-          query: (sql: string) => {
-            all: () => unknown[];
-          };
-        };
+      if (!connection || typeof connection !== 'object') {
+        return false;
+      }
+
+      // bun:sqlite Database（有 .query() 但没有 callback-based .all()）
+      if ('query' in connection && typeof (connection as any).query === 'function' && !('all' in connection && 'run' in connection)) {
+        const db = connection as { query: (sql: string) => { all: () => unknown[] } };
         db.query('SELECT 1').all();
         return true;
       }
+
+      // @vscode/sqlite3 Database（callback-based .all()）
+      if ('all' in connection && typeof (connection as any).all === 'function') {
+        await new Promise<void>((resolve, reject) => {
+          (connection as any).all('SELECT 1', [], (err: Error | null) => {
+            if (err) reject(err);
+            else resolve();
+          });
+        });
+        return true;
+      }
+
       return false;
     } catch (_error) {
       return false;

package/src/database/connection-pool.ts

@@ -185,9 +185,10 @@ export class ConnectionPool {
       const { Database } = await import('bun:sqlite');
       return new Database(config.path);
     }
-    // Node.js：使用 better-sqlite3
-    const BetterSqlite3 = require('better-sqlite3') as typeof import('better-sqlite3');
-    return BetterSqlite3(config.path);
+    // Node.js：使用 @vscode/sqlite3
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const sqlite3 = require('@vscode/sqlite3') as any;
+    return new sqlite3.Database(config.path);
   }
 
   /**

package/src/database/service.ts

@@ -113,7 +113,7 @@ export class DatabaseService {
 
   /**
    * 执行 SQL 查询
-   * SQLite 返回同步结果，PostgreSQL/MySQL 返回异步结果
+   * SQLite (bun:sqlite) 返回同步结果；@vscode/sqlite3 / PostgreSQL / MySQL 返回异步结果
    */
   public query<T = unknown>(sql: string, params?: unknown[]): T[] | Promise<T[]> {
     const session = getCurrentSession();
@@ -139,18 +139,20 @@ export class DatabaseService {
 
   /**
    * SQLite 查询实现
+   * bun:sqlite 使用同步 .query().all()；@vscode/sqlite3 使用异步 callback .all()
    */
   private querySqlite<T = unknown>(
     connection: unknown,
     sql: string,
     params?: unknown[],
-  ): T[] {
-    // Bun SQLite Database 对象
+  ): T[] | Promise<T[]> {
+    // bun:sqlite Database 对象（有 .query() 方法）
     if (
       connection &&
       typeof connection === 'object' &&
       'query' in connection &&
-      typeof connection.query === 'function'
+      typeof (connection as any).query === 'function' &&
+      !('all' in connection && 'run' in connection)
     ) {
       const db = connection as {
         query: (sql: string) => {
@@ -160,12 +162,26 @@ export class DatabaseService {
       };
 
       const statement = db.query(sql);
-      // Bun SQLite 的 all() 方法接受参数
       const result =
         params && params.length > 0 ? statement.all(...params) : statement.all();
       return result;
     }
 
+    // @vscode/sqlite3 Database 对象（有 .all() callback 方法）
+    if (
+      connection &&
+      typeof connection === 'object' &&
+      'all' in connection &&
+      typeof (connection as any).all === 'function'
+    ) {
+      return new Promise<T[]>((resolve, reject) => {
+        (connection as any).all(sql, params ?? [], (err: Error | null, rows: T[]) => {
+          if (err) reject(err);
+          else resolve(rows ?? []);
+        });
+      });
+    }
+
     throw new Error('Invalid SQLite connection');
   }
 

package/src/database/sqlite-adapter.ts

@@ -40,7 +40,7 @@ export class Semaphore {
 
 /**
  * SQLite 适配器（自动感知运行时）
- * Bun 平台下使用 bun:sqlite，Node.js 平台下使用 better-sqlite3
+ * Bun 平台下使用 bun:sqlite，Node.js 平台下使用 @vscode/sqlite3
  */
 export class SqliteAdapter {
   private readonly db: unknown;
@@ -58,10 +58,12 @@ export class SqliteAdapter {
       }
       this.db = db;
     } else {
-      const BetterSqlite3 = require('better-sqlite3') as typeof import('better-sqlite3');
-      const db = BetterSqlite3(config.database);
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const sqlite3 = require('@vscode/sqlite3') as any;
+      const db: any = new sqlite3.Database(config.database);
       if (config.wal !== false) {
-        db.exec('PRAGMA journal_mode = WAL;');
+        // Operations are serialized internally; WAL is queued before any query runs
+        db.run('PRAGMA journal_mode = WAL;');
       }
       this.db = db;
     }
@@ -69,15 +71,18 @@ export class SqliteAdapter {
     this.semaphore = new Semaphore(config.maxWriteConcurrency ?? 1);
   }
 
-  public query<T = unknown>(sql: string, params: unknown[] = []): T[] {
+  public async query<T = unknown>(sql: string, params: unknown[] = []): Promise<T[]> {
     if (this.isBun) {
       const db = this.db as import('bun:sqlite').Database;
       const stmt = db.query(sql);
       return stmt.all(...params as Parameters<typeof stmt.all>) as T[];
     }
-    const db = this.db as import('better-sqlite3').Database;
-    const stmt = db.prepare(sql);
-    return stmt.all(...params) as T[];
+    return new Promise<T[]>((resolve, reject) => {
+      (this.db as any).all(sql, params, (err: Error | null, rows: T[]) => {
+        if (err) reject(err);
+        else resolve(rows ?? []);
+      });
+    });
   }
 
   public async execute(sql: string, params: unknown[] = []): Promise<void> {
@@ -86,9 +91,12 @@ export class SqliteAdapter {
       const stmt = db.query(sql);
       stmt.run(...params as Parameters<typeof stmt.run>);
     } else {
-      const db = this.db as import('better-sqlite3').Database;
-      const stmt = db.prepare(sql);
-      stmt.run(...params);
+      return new Promise<void>((resolve, reject) => {
+        (this.db as any).run(sql, params, (err: Error | null) => {
+          if (err) reject(err);
+          else resolve();
+        });
+      });
     }
   }
 

package/tests/platform/shared/database.cases.ts

@@ -7,22 +7,22 @@ import { SqliteManager } from '../../../src/database/sqlite-adapter';
 export function runDatabaseCases(suite: TestSuite, engine: PlatformEngine): void {
   const { test, expect } = suite;
 
-  // better-sqlite3 is not supported when running Node-platform tests under Bun runtime
-  const skipBetterSqlite = engine === 'node' && typeof (globalThis as any).Bun !== 'undefined';
+  // @vscode/sqlite3 is a native Node.js addon; skip when Node-platform tests run under Bun runtime
+  const skipNodeSqlite = engine === 'node' && typeof (globalThis as any).Bun !== 'undefined';
 
-  test('SqliteAdapter: create table, insert and query', () => {
-    if (skipBetterSqlite) {
-      // better-sqlite3 is not supported in Bun — this test must run under Node.js
-      console.log('[skip] better-sqlite3 not available in Bun runtime; run with vitest for Node platform');
+  test('SqliteAdapter: create table, insert and query', async () => {
+    if (skipNodeSqlite) {
+      // @vscode/sqlite3 is not available in Bun — this test must run under Node.js
+      console.log('[skip] @vscode/sqlite3 not available in Bun runtime; run with vitest for Node platform');
       return;
     }
     const dbPath = join(tmpdir(), `platform-db-test-${engine}-${Date.now()}.db`);
     const manager = new SqliteManager();
     const adapter = manager.getOrCreate('test', { database: dbPath, wal: false });
 
-    adapter.query('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
-    adapter.query("INSERT INTO users (name) VALUES ('Alice')");
-    const rows = adapter.query<{ id: number; name: string }>('SELECT * FROM users');
+    await adapter.query('CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY, name TEXT)');
+    await adapter.query("INSERT INTO users (name) VALUES ('Alice')");
+    const rows = await adapter.query<{ id: number; name: string }>('SELECT * FROM users');
 
     expect(rows.length).toBeGreaterThanOrEqual(1);
     expect(rows[0]!.name).toBe('Alice');