@visactor/vquery 0.1.28

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 VisActor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# VQuery

package/dist/db/duckDb.d.ts

@@ -0,0 +1,28 @@
+export declare class DuckDB {
+    private db;
+    private connection;
+    constructor();
+    /**
+     * @description 初始化 DuckDB 实例
+     */
+    instantiate: () => Promise<void>;
+    /**
+     * @description 释放 DuckDB 实例
+     */
+    close: () => Promise<void>;
+    /**
+     * 注册文件到 DuckDB 实例
+     * @param fileName 文件名
+     * @param source 文件内容
+     */
+    registerFile: <T extends string | ArrayBuffer | Uint8Array | Blob>(fileName: string, source: T) => Promise<void>;
+    /**
+     * @description 执行 SQL 查询
+     * @param sql SQL 语句
+     * @returns 查询结果
+     */
+    query: (sql: string) => Promise<{
+        dataset: any[];
+        table: any;
+    }>;
+}

package/dist/db/indexedDb.d.ts

@@ -0,0 +1,11 @@
+export declare class IndexedDB {
+    private db;
+    private dbName;
+    private storeName;
+    constructor(dbName: string);
+    open: () => Promise<void>;
+    close: () => void;
+    writeFile: (fileName: string, data: Blob) => Promise<void>;
+    readFile: (fileName: string) => Promise<Blob | null>;
+    listFiles: () => Promise<string[]>;
+}

package/dist/index.cjs

@@ -0,0 +1,218 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    VQuery: ()=>VQuery
+});
+const duckdb_wasm_namespaceObject = require("@duckdb/duckdb-wasm");
+class DuckDB {
+    db = null;
+    connection = null;
+    constructor(){}
+    instantiate = async ()=>{
+        const JSDELIVR_BUNDLES = (0, duckdb_wasm_namespaceObject.getJsDelivrBundles)();
+        const bundle = await (0, duckdb_wasm_namespaceObject.selectBundle)(JSDELIVR_BUNDLES);
+        const worker_url = URL.createObjectURL(new Blob([
+            `importScripts("${bundle.mainWorker}");`
+        ], {
+            type: "text/javascript"
+        }));
+        const worker = new Worker(worker_url);
+        const logger = new duckdb_wasm_namespaceObject.ConsoleLogger();
+        this.db = new duckdb_wasm_namespaceObject.AsyncDuckDB(logger, worker);
+        await this.db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+        URL.revokeObjectURL(worker_url);
+        this.connection = await this.db.connect();
+    };
+    close = async ()=>{
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+        }
+        if (this.db) {
+            await this.db.terminate();
+            this.db = null;
+        }
+    };
+    registerFile = async (fileName, source)=>{
+        if (!this.db) throw new Error('db is null');
+        let uint8Array;
+        if ('string' == typeof source) {
+            const response = await fetch(source);
+            const buffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(buffer);
+        } else if (source instanceof Blob) {
+            const buffer = await source.arrayBuffer();
+            uint8Array = new Uint8Array(buffer);
+        } else if (source instanceof ArrayBuffer) uint8Array = new Uint8Array(source);
+        else if (source instanceof Uint8Array) uint8Array = source;
+        else throw new Error('Unsupported source type');
+        await this.db.registerFileBuffer(fileName, uint8Array);
+    };
+    query = async (sql)=>{
+        if (!this.connection) throw new Error('connection is null');
+        const table = await this.connection.query(sql);
+        const dataset = table.toArray().map((row)=>row.toJSON());
+        return {
+            dataset,
+            table
+        };
+    };
+}
+class IndexedDB {
+    db = null;
+    dbName;
+    storeName = 'files';
+    constructor(dbName){
+        this.dbName = dbName;
+    }
+    open = ()=>new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, 1);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, {
+                    keyPath: 'name'
+                });
+            };
+            request.onsuccess = (event)=>{
+                this.db = event.target.result;
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    close = ()=>{
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    };
+    writeFile = (fileName, data)=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.put({
+                name: fileName,
+                data
+            });
+            request.onsuccess = ()=>{
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    readFile = (fileName)=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(fileName);
+            request.onsuccess = (event)=>{
+                const result = event.target.result;
+                result ? resolve(result.data) : resolve(null);
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    listFiles = ()=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.getAllKeys();
+            request.onsuccess = (event)=>{
+                const keys = event.target.result;
+                resolve(keys);
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+}
+class VQuery {
+    duckDB;
+    indexedDB;
+    constructor(dbName = 'vquery'){
+        this.duckDB = new DuckDB();
+        this.indexedDB = new IndexedDB(dbName);
+    }
+    instantiate = async ()=>{
+        await this.duckDB.instantiate();
+        await this.indexedDB.open();
+    };
+    close = async ()=>{
+        await this.duckDB.close();
+        this.indexedDB.close();
+    };
+    registerFile = async (fileName, source)=>{
+        let blob;
+        if ('string' == typeof source) {
+            const response = await fetch(source);
+            blob = await response.blob();
+        } else if (source instanceof ArrayBuffer) blob = new Blob([
+            source
+        ]);
+        else if (source instanceof Uint8Array) blob = new Blob([
+            source.slice()
+        ]);
+        else if (source instanceof Blob) blob = source;
+        else throw new Error('Unsupported source type');
+        await this.indexedDB.writeFile(fileName, blob);
+        await this.duckDB.registerFile(fileName, blob);
+    };
+    loadFile = async (fileName)=>{
+        const blob = await this.indexedDB.readFile(fileName);
+        if (blob) await this.duckDB.registerFile(fileName, blob);
+        else throw new Error(`File ${fileName} not found in IndexedDB`);
+    };
+    listFiles = ()=>this.indexedDB.listFiles();
+    query = async (sql)=>{
+        const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        const result = await this.duckDB.query(sql);
+        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        return {
+            ...result,
+            performance: {
+                startAt: start,
+                endAt: end,
+                duration: Number(end) - Number(start)
+            }
+        };
+    };
+}
+exports.VQuery = __webpack_exports__.VQuery;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "VQuery"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+export declare class VQuery {
+    private duckDB;
+    private indexedDB;
+    constructor(dbName?: string);
+    /**
+     * @description 初始化数据库
+     */
+    instantiate: () => Promise<void>;
+    /**
+     * @description 关闭数据库
+     */
+    close: () => Promise<void>;
+    /**
+     * @description 注册文件
+     * @param fileName 文件名
+     * @param source 文件内容
+     */
+    registerFile: (fileName: string, source: string | ArrayBuffer | Uint8Array | Blob) => Promise<void>;
+    /**
+     * @description 从 IndexedDB 读取文件并注册到 DuckDB
+     * @param fileName 文件名
+     */
+    loadFile: (fileName: string) => Promise<void>;
+    /**
+     * @description 列出 IndexedDB 中的所有文件
+     */
+    listFiles: () => Promise<string[]>;
+    /**
+     * @description 执行 SQL 查询
+     * @param sql SQL 语句
+     */
+    query: (sql: string) => Promise<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        dataset: any[];
+        table: any;
+    }>;
+}

package/dist/index.js

@@ -0,0 +1,184 @@
+import { AsyncDuckDB, ConsoleLogger, getJsDelivrBundles, selectBundle } from "@duckdb/duckdb-wasm";
+class DuckDB {
+    db = null;
+    connection = null;
+    constructor(){}
+    instantiate = async ()=>{
+        const JSDELIVR_BUNDLES = getJsDelivrBundles();
+        const bundle = await selectBundle(JSDELIVR_BUNDLES);
+        const worker_url = URL.createObjectURL(new Blob([
+            `importScripts("${bundle.mainWorker}");`
+        ], {
+            type: "text/javascript"
+        }));
+        const worker = new Worker(worker_url);
+        const logger = new ConsoleLogger();
+        this.db = new AsyncDuckDB(logger, worker);
+        await this.db.instantiate(bundle.mainModule, bundle.pthreadWorker);
+        URL.revokeObjectURL(worker_url);
+        this.connection = await this.db.connect();
+    };
+    close = async ()=>{
+        if (this.connection) {
+            await this.connection.close();
+            this.connection = null;
+        }
+        if (this.db) {
+            await this.db.terminate();
+            this.db = null;
+        }
+    };
+    registerFile = async (fileName, source)=>{
+        if (!this.db) throw new Error('db is null');
+        let uint8Array;
+        if ('string' == typeof source) {
+            const response = await fetch(source);
+            const buffer = await response.arrayBuffer();
+            uint8Array = new Uint8Array(buffer);
+        } else if (source instanceof Blob) {
+            const buffer = await source.arrayBuffer();
+            uint8Array = new Uint8Array(buffer);
+        } else if (source instanceof ArrayBuffer) uint8Array = new Uint8Array(source);
+        else if (source instanceof Uint8Array) uint8Array = source;
+        else throw new Error('Unsupported source type');
+        await this.db.registerFileBuffer(fileName, uint8Array);
+    };
+    query = async (sql)=>{
+        if (!this.connection) throw new Error('connection is null');
+        const table = await this.connection.query(sql);
+        const dataset = table.toArray().map((row)=>row.toJSON());
+        return {
+            dataset,
+            table
+        };
+    };
+}
+class IndexedDB {
+    db = null;
+    dbName;
+    storeName = 'files';
+    constructor(dbName){
+        this.dbName = dbName;
+    }
+    open = ()=>new Promise((resolve, reject)=>{
+            const request = indexedDB.open(this.dbName, 1);
+            request.onupgradeneeded = (event)=>{
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) db.createObjectStore(this.storeName, {
+                    keyPath: 'name'
+                });
+            };
+            request.onsuccess = (event)=>{
+                this.db = event.target.result;
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    close = ()=>{
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    };
+    writeFile = (fileName, data)=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readwrite');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.put({
+                name: fileName,
+                data
+            });
+            request.onsuccess = ()=>{
+                resolve();
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    readFile = (fileName)=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.get(fileName);
+            request.onsuccess = (event)=>{
+                const result = event.target.result;
+                result ? resolve(result.data) : resolve(null);
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+    listFiles = ()=>new Promise((resolve, reject)=>{
+            if (!this.db) return reject('DB is not open');
+            const transaction = this.db.transaction([
+                this.storeName
+            ], 'readonly');
+            const store = transaction.objectStore(this.storeName);
+            const request = store.getAllKeys();
+            request.onsuccess = (event)=>{
+                const keys = event.target.result;
+                resolve(keys);
+            };
+            request.onerror = (event)=>{
+                reject(event.target.error);
+            };
+        });
+}
+class VQuery {
+    duckDB;
+    indexedDB;
+    constructor(dbName = 'vquery'){
+        this.duckDB = new DuckDB();
+        this.indexedDB = new IndexedDB(dbName);
+    }
+    instantiate = async ()=>{
+        await this.duckDB.instantiate();
+        await this.indexedDB.open();
+    };
+    close = async ()=>{
+        await this.duckDB.close();
+        this.indexedDB.close();
+    };
+    registerFile = async (fileName, source)=>{
+        let blob;
+        if ('string' == typeof source) {
+            const response = await fetch(source);
+            blob = await response.blob();
+        } else if (source instanceof ArrayBuffer) blob = new Blob([
+            source
+        ]);
+        else if (source instanceof Uint8Array) blob = new Blob([
+            source.slice()
+        ]);
+        else if (source instanceof Blob) blob = source;
+        else throw new Error('Unsupported source type');
+        await this.indexedDB.writeFile(fileName, blob);
+        await this.duckDB.registerFile(fileName, blob);
+    };
+    loadFile = async (fileName)=>{
+        const blob = await this.indexedDB.readFile(fileName);
+        if (blob) await this.duckDB.registerFile(fileName, blob);
+        else throw new Error(`File ${fileName} not found in IndexedDB`);
+    };
+    listFiles = ()=>this.indexedDB.listFiles();
+    query = async (sql)=>{
+        const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        const result = await this.duckDB.query(sql);
+        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        return {
+            ...result,
+            performance: {
+                startAt: start,
+                endAt: end,
+                duration: Number(end) - Number(start)
+            }
+        };
+    };
+}
+export { VQuery };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@visactor/vquery",
+  "version": "0.1.28",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@duckdb/duckdb-wasm": "latest"
+  },
+  "devDependencies": {
+    "@eslint/js": "^9.35.0",
+    "@rslib/core": "^0.15.1",
+    "@rstest/core": "^0.5.1",
+    "@types/node": "^22.18.10",
+    "@rstest/coverage-istanbul": "^0.0.2",
+    "eslint": "^9.35.0",
+    "globals": "^16.3.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.43.0"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "lint": "eslint .",
+    "test": "rstest",
+    "type-check": "tsc --noEmit"
+  }
+}