@visactor/vquery 0.2.2 → 0.2.5

package/dist/cjs/adapters/index.d.ts

@@ -0,0 +1 @@
+export { IndexedDBAdapter, InMemoryAdapter } from './storage-adapter';

package/dist/cjs/adapters/query-adapter/duckdbNodeAdapter.d.ts

@@ -0,0 +1,14 @@
+import { QueryAdapter } from '../../types';
+export declare class DuckDBNodeQueryAdapter implements QueryAdapter {
+    private bindings;
+    private connection;
+    constructor();
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeFile: <T extends Blob>(fileName: string, source: T) => Promise<void>;
+    query: (sql: string) => Promise<{
+        dataset: any[];
+        table: any;
+    }>;
+    getSchema: (fileName: string) => Promise<any>;
+}

package/dist/cjs/adapters/query-adapter/duckdbWebAdapter.d.ts

@@ -0,0 +1,14 @@
+import { QueryAdapter } from '../../types';
+export declare class DuckDBWebQueryAdapter implements QueryAdapter {
+    private db;
+    private connection;
+    constructor();
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeFile: <T extends Blob>(fileName: string, source: T) => Promise<void>;
+    query: (sql: string) => Promise<{
+        dataset: any[];
+        table: any;
+    }>;
+    getSchema: (fileName: string) => Promise<any>;
+}

package/dist/cjs/adapters/storage-adapter/index.d.ts

@@ -0,0 +1,2 @@
+export { IndexedDBAdapter } from './indexeddbAdapter';
+export { InMemoryAdapter } from './inmemoryAdapter';

package/dist/{db/indexedDb.d.ts → cjs/adapters/storage-adapter/indexeddbAdapter.d.ts}

@@ -1,12 +1,12 @@
-import { DatasetSource } from '../types';
-import { DatasetSchema } from '../types/DataSet';
-export declare class IndexedDB {
+import { DatasetSource, StorageAdapter } from '../../types';
+import { DatasetSchema } from '../../types/DataSet';
+export declare class IndexedDBAdapter implements StorageAdapter {
     private db;
     private dbName;
     private datasetStoreName;
-    constructor(dbName: string);
+    constructor(dbName?: string);
     open: () => Promise<void>;
-    close: () => void;
+    close: () => Promise<void>;
     writeDataset: (datasetId: string, datasetSchema: DatasetSchema, datasetSource?: DatasetSource) => Promise<void>;
     readDataset: (datasetId: string) => Promise<{
         datasetSource?: DatasetSource;

package/dist/cjs/adapters/storage-adapter/inmemoryAdapter.d.ts

@@ -0,0 +1,22 @@
+import { DatasetSource, StorageAdapter } from '../../types';
+import { DatasetSchema } from '../../types/DataSet';
+type StoredDataset = {
+    datasetId: string;
+    datasetSchema: DatasetSchema;
+    datasetSource?: DatasetSource;
+};
+export declare class InMemoryAdapter implements StorageAdapter {
+    private datasets;
+    private isOpen;
+    constructor();
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeDataset: (datasetId: string, datasetSchema: DatasetSchema, datasetSource?: DatasetSource) => Promise<void>;
+    readDataset: (datasetId: string) => Promise<{
+        datasetSource?: DatasetSource;
+        datasetSchema: DatasetSchema;
+    } | null>;
+    deleteDataset: (datasetId: string) => Promise<void>;
+    listDatasets: () => Promise<StoredDataset[]>;
+}
+export {};

package/dist/cjs/browser.d.ts

@@ -0,0 +1,5 @@
+export { convertDSLToSQL } from './dataset';
+export { DatasetSourceBuilder } from './data-source-builder/dataSourceBuilder';
+export * from './utils';
+export * from './types';
+export { VQuery } from './vquery-browser';

package/dist/{dataset → cjs/dataset}/dataset.d.ts

@@ -1,11 +1,10 @@
 import { DatasetColumn, DatasetSource, QueryDSL } from '../types';
-import { DuckDB } from '../db/duckDb';
-import { IndexedDB } from '../db/indexedDb';
+import { QueryAdapter, StorageAdapter } from '../types';
 export declare class Dataset {
-    private duckDB;
-    private indexedDB;
+    private queryAdapter;
+    private storageAdapter;
     private _datasetId;
-    constructor(duckDB: DuckDB, indexedDB: IndexedDB, datasetId: string);
+    constructor(duckDB: QueryAdapter, indexedDB: StorageAdapter, datasetId: string);
     init(temporaryColumns?: DatasetColumn[], temporaryDatasetSource?: DatasetSource): Promise<void>;
     createOrReplaceView(columns: DatasetColumn[], datasetSource: DatasetSource): Promise<void>;
     query<T extends Record<string, number | string>>(queryDSL: QueryDSL<T>): Promise<{

package/dist/{index.cjs → cjs/node.cjs}

@@ -177,16 +177,16 @@ const convertDSLToSQL = (dsl, tableName)=>{
     return inlineParameters(compiled.sql, compiled.parameters);
 };
 class Dataset {
-    duckDB;
-    indexedDB;
+    queryAdapter;
+    storageAdapter;
     _datasetId;
-    constructor(duckDB, indexedDB1, datasetId){
-        this.duckDB = duckDB;
-        this.indexedDB = indexedDB1;
+    constructor(duckDB, indexedDB, datasetId){
+        this.queryAdapter = duckDB;
+        this.storageAdapter = indexedDB;
         this._datasetId = datasetId;
     }
     async init(temporaryColumns, temporaryDatasetSource) {
-        const datasetInfo = await this.indexedDB.readDataset(this._datasetId);
+        const datasetInfo = await this.storageAdapter.readDataset(this._datasetId);
         if (!datasetInfo) throw new Error(`Dataset ${this._datasetId} not found`);
         const columns = temporaryColumns ? temporaryColumns : datasetInfo.datasetSchema.columns;
         const datasetSource = temporaryDatasetSource || datasetInfo.datasetSource;
@@ -209,11 +209,11 @@ class Dataset {
         if (datasetSource) {
             const readFunction = readFunctionMap[datasetSource.type];
             if (!readFunction) throw new Error(`Unsupported dataSource type: ${datasetSource.type}`);
-            await this.duckDB.writeFile(this._datasetId, datasetSource.blob);
+            await this.queryAdapter.writeFile(this._datasetId, datasetSource.blob);
             const columnsStruct = `{${columns.map((c)=>`'${c.name}': '${dataTypeMap[c.type] || 'VARCHAR'}'`).join(', ')}}`;
             const columnNames = columns.map((c)=>`"${c.name}"`).join(', ');
             const createViewSql = `CREATE OR REPLACE VIEW "${this._datasetId}" AS SELECT ${columnNames} FROM ${readFunction}('${this._datasetId}', columns=${columnsStruct})`;
-            await this.duckDB.query(createViewSql);
+            await this.queryAdapter.query(createViewSql);
         }
     }
     async query(queryDSL) {
@@ -222,7 +222,7 @@ class Dataset {
     }
     async queryBySQL(sql) {
         const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
-        const result = await this.duckDB.query(sql);
+        const result = await this.queryAdapter.query(sql);
         const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
         return {
             ...result,
@@ -234,167 +234,12 @@ class Dataset {
         };
     }
     async disconnect() {
-        await this.duckDB.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
+        await this.queryAdapter.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
     }
     get datasetId() {
         return this._datasetId;
     }
 }
-const duckdb_wasm_namespaceObject = require("@duckdb/duckdb-wasm");
-class DuckDB {
-    db = null;
-    connection = null;
-    constructor(){}
-    init = async ()=>{
-        const MANUAL_BUNDLES = {
-            mvp: {
-                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm', __rslib_import_meta_url__).href,
-                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-mvp.worker.js', __rslib_import_meta_url__).toString()
-            },
-            eh: {
-                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm', __rslib_import_meta_url__).href,
-                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-eh.worker.js', __rslib_import_meta_url__).toString()
-            }
-        };
-        const bundle = await (0, duckdb_wasm_namespaceObject.selectBundle)(MANUAL_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;
-        }
-    };
-    writeFile = async (fileName, source)=>{
-        if (!this.db) throw new Error('db is null');
-        let uint8Array;
-        if (source instanceof Blob) {
-            const buffer = await source.arrayBuffer();
-            uint8Array = new Uint8Array(buffer);
-        } 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
-        };
-    };
-    getSchema = async (fileName)=>{
-        if (!this.connection) throw new Error('connection is null');
-        const result = await this.connection.query(`PRAGMA table_info('${fileName}')`);
-        return result.toArray().map((row)=>row.toJSON());
-    };
-}
-class IndexedDB {
-    db = null;
-    dbName;
-    datasetStoreName = 'vqueryDatasets';
-    constructor(dbName){
-        this.dbName = dbName;
-    }
-    open = ()=>new Promise((resolve, reject)=>{
-            const request = indexedDB.open(this.dbName, 2);
-            request.onupgradeneeded = (event)=>{
-                const db = event.target.result;
-                if (!db.objectStoreNames.contains(this.datasetStoreName)) db.createObjectStore(this.datasetStoreName, {
-                    keyPath: 'datasetId'
-                });
-            };
-            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;
-        }
-    };
-    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
-            if (!this.db) return reject('DB is not open');
-            const transaction = this.db.transaction([
-                this.datasetStoreName
-            ], 'readwrite');
-            const store = transaction.objectStore(this.datasetStoreName);
-            const request = store.put({
-                datasetId,
-                datasetSchema,
-                datasetSource
-            });
-            request.onsuccess = ()=>{
-                resolve();
-            };
-            request.onerror = (event)=>{
-                reject(event.target.error);
-            };
-        });
-    readDataset = (datasetId)=>new Promise((resolve, reject)=>{
-            if (!this.db) return reject('DB is not open');
-            const transaction = this.db.transaction([
-                this.datasetStoreName
-            ], 'readonly');
-            const store = transaction.objectStore(this.datasetStoreName);
-            const request = store.get(datasetId);
-            request.onsuccess = (event)=>{
-                const result = event.target.result;
-                resolve(result || null);
-            };
-            request.onerror = (event)=>{
-                reject(event.target.error);
-            };
-        });
-    deleteDataset = (datasetId)=>new Promise((resolve, reject)=>{
-            if (!this.db) return reject('DB is not open');
-            const transaction = this.db.transaction([
-                this.datasetStoreName
-            ], 'readwrite');
-            const store = transaction.objectStore(this.datasetStoreName);
-            const request = store.delete(datasetId);
-            request.onsuccess = ()=>{
-                resolve();
-            };
-            request.onerror = (event)=>{
-                reject(event.target.error);
-            };
-        });
-    listDatasets = ()=>new Promise((resolve, reject)=>{
-            if (!this.db) return reject('DB is not open');
-            const transaction = this.db.transaction([
-                this.datasetStoreName
-            ], 'readonly');
-            const store = transaction.objectStore(this.datasetStoreName);
-            const request = store.getAll();
-            request.onsuccess = (event)=>{
-                const result = event.target.result;
-                resolve(result);
-            };
-            request.onerror = (event)=>{
-                reject(event.target.error);
-            };
-        });
-}
 const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
 const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
 const isBase64Url = (url)=>url.startsWith('data:');
@@ -489,18 +334,125 @@ class DatasetSourceBuilder {
         return await response.blob();
     }
 }
+class InMemoryAdapter {
+    datasets = new Map();
+    isOpen = false;
+    constructor(){}
+    open = async ()=>{
+        this.isOpen = true;
+        if (!this.isOpen) this.datasets = new Map();
+    };
+    close = async ()=>{
+        this.isOpen = false;
+        this.datasets.clear();
+    };
+    writeDataset = (datasetId, datasetSchema, datasetSource)=>new Promise((resolve, reject)=>{
+            try {
+                const record = {
+                    datasetId,
+                    datasetSchema,
+                    datasetSource
+                };
+                this.datasets.set(datasetId, record);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    readDataset = (datasetId)=>new Promise((resolve, reject)=>{
+            try {
+                const record = this.datasets.get(datasetId);
+                resolve(record ? record : null);
+            } catch (error) {
+                reject(error);
+            }
+        });
+    deleteDataset = (datasetId)=>new Promise((resolve, reject)=>{
+            try {
+                this.datasets.delete(datasetId);
+                resolve();
+            } catch (error) {
+                reject(error);
+            }
+        });
+    listDatasets = ()=>new Promise((resolve, reject)=>{
+            try {
+                resolve(Array.from(this.datasets.values()));
+            } catch (error) {
+                reject(error);
+            }
+        });
+}
+const blocking_namespaceObject = require("@duckdb/duckdb-wasm/blocking");
+const external_node_module_namespaceObject = require("node:module");
+class DuckDBNodeQueryAdapter {
+    bindings = null;
+    connection = null;
+    constructor(){}
+    open = async ()=>{
+        const require1 = (0, external_node_module_namespaceObject.createRequire)(__rslib_import_meta_url__);
+        const MANUAL_BUNDLES = {
+            mvp: {
+                mainModule: require1.resolve('@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm'),
+                mainWorker: ''
+            },
+            eh: {
+                mainModule: require1.resolve('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm'),
+                mainWorker: ''
+            }
+        };
+        const logger = new blocking_namespaceObject.ConsoleLogger();
+        this.bindings = await (0, blocking_namespaceObject.createDuckDB)(MANUAL_BUNDLES, logger, blocking_namespaceObject.NODE_RUNTIME);
+        await this.bindings.instantiate(()=>{});
+        this.bindings.open({});
+        this.connection = this.bindings.connect();
+    };
+    close = async ()=>{
+        if (this.connection) {
+            this.connection.close();
+            this.connection = null;
+        }
+        if (this.bindings) {
+            this.bindings.reset();
+            this.bindings = null;
+        }
+    };
+    writeFile = async (fileName, source)=>{
+        if (!this.bindings) throw new Error('bindings is null');
+        let uint8Array;
+        if (source instanceof Blob) {
+            const buffer = await source.arrayBuffer();
+            uint8Array = new Uint8Array(buffer);
+        } else throw new Error('Unsupported source type');
+        await this.bindings.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
+        };
+    };
+    getSchema = async (fileName)=>{
+        if (!this.connection) throw new Error('connection is null');
+        const result = await this.connection.query(`PRAGMA table_info('${fileName}')`);
+        return result.toArray().map((row)=>row.toJSON());
+    };
+}
 class VQuery {
-    duckDB;
-    indexedDB;
+    queryAdapter;
+    storageAdapter;
     isInitialized = false;
-    constructor(dbName = 'vquery'){
-        this.duckDB = new DuckDB();
-        this.indexedDB = new IndexedDB(dbName);
+    constructor(){
+        this.queryAdapter = new DuckDBNodeQueryAdapter();
+        this.storageAdapter = new InMemoryAdapter();
     }
     async checkInitialized() {
         if (!this.isInitialized) {
-            await this.duckDB.init();
-            await this.indexedDB.open();
+            await this.queryAdapter.open();
+            await this.storageAdapter.open();
             this.isInitialized = true;
         }
     }
@@ -516,7 +468,7 @@ class VQuery {
             datasetAlias: datasetId,
             columns: columns
         };
-        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
+        await this.storageAdapter.writeDataset(datasetId, datasetSchema, datasetSource);
     }
     async updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
         await this.checkInitialized();
@@ -527,33 +479,34 @@ class VQuery {
             datasetAlias: datasetId,
             columns: columns
         };
-        await this.indexedDB.writeDataset(datasetId, datasetSchema, datasetSource);
+        await this.storageAdapter.writeDataset(datasetId, datasetSchema, datasetSource);
     }
     async dropDataset(datasetId) {
         await this.checkInitialized();
         await this.checkDatasetExists(datasetId);
-        await this.indexedDB.deleteDataset(datasetId);
+        await this.storageAdapter.deleteDataset(datasetId);
     }
     async connectDataset(datasetId, temporaryColumns, temporaryRawDatasetSource) {
         await this.checkInitialized();
         await this.checkDatasetExists(datasetId);
-        const dataset = new Dataset(this.duckDB, this.indexedDB, datasetId);
+        const dataset = new Dataset(this.queryAdapter, this.storageAdapter, datasetId);
         const temporaryDatasetSource = temporaryRawDatasetSource ? await DatasetSourceBuilder.from(temporaryRawDatasetSource).build() : void 0;
         await dataset.init(temporaryColumns, temporaryDatasetSource);
         return dataset;
     }
     async hasDataset(datasetId) {
         await this.checkInitialized();
-        const datasets = await this.indexedDB.listDatasets();
+        const datasets = await this.storageAdapter.listDatasets();
         return datasets.some((item)=>item.datasetId === datasetId);
     }
     async listDatasets() {
         await this.checkInitialized();
-        return this.indexedDB.listDatasets();
+        return this.storageAdapter.listDatasets();
     }
     async close() {
         await this.checkInitialized();
-        await this.duckDB.close();
+        await this.queryAdapter.close();
+        await this.storageAdapter.close();
     }
 }
 exports.DatasetSourceBuilder = __webpack_exports__.DatasetSourceBuilder;
@@ -562,14 +515,14 @@ exports.convertDSLToSQL = __webpack_exports__.convertDSLToSQL;
 exports.isBase64Url = __webpack_exports__.isBase64Url;
 exports.isHttpUrl = __webpack_exports__.isHttpUrl;
 exports.isUrl = __webpack_exports__.isUrl;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+for(var __rspack_i in __webpack_exports__)if (-1 === [
     "DatasetSourceBuilder",
     "VQuery",
     "convertDSLToSQL",
     "isBase64Url",
     "isHttpUrl",
     "isUrl"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });

package/dist/{index.d.ts → cjs/node.d.ts}

@@ -1,5 +1,5 @@
-export { VQuery } from './vquery';
 export { convertDSLToSQL } from './dataset';
 export { DatasetSourceBuilder } from './data-source-builder/dataSourceBuilder';
 export * from './utils';
 export * from './types';
+export { VQuery } from './vquery-node';

package/dist/{sql-builder → cjs/sql-builder}/utils.d.ts

@@ -1,5 +1,5 @@
 import { Where, WhereClause, WhereGroup, WhereLeaf } from '../types';
-import { SelectItem } from '../types/QueryDSL/Select';
+import { SelectItem } from '../types/dsl/Select';
 export declare const isSelectItem: <T>(item: keyof T | SelectItem<T>) => item is SelectItem<T>;
 export declare const isWhereLeaf: <T>(where: Where<T> | WhereClause<T>) => where is WhereLeaf<T>;
 export declare const isWhereGroup: <T>(where: Where<T> | WhereClause<T>) => where is WhereGroup<T>;

package/dist/cjs/types/adapters/QueryAdapter.d.ts

@@ -0,0 +1,11 @@
+import { QueryResult } from '../QueryResult';
+export interface QueryAdapter {
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeFile: <T extends Blob>(fileName: string, source: T) => Promise<void>;
+    getSchema: (fileName: string) => Promise<QueryResult>;
+    query: (sql: string) => Promise<{
+        dataset: any[];
+        table: any;
+    }>;
+}

package/dist/cjs/types/adapters/StorageAdapter.d.ts

@@ -0,0 +1,17 @@
+import { DatasetSchema } from '../DataSet';
+import { DatasetSource } from '../DataSource';
+export interface StorageAdapter {
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeDataset: (datasetId: string, datasetSchema: DatasetSchema, datasetSource?: DatasetSource) => Promise<void>;
+    readDataset: (datasetId: string) => Promise<{
+        datasetSchema: DatasetSchema;
+        datasetSource?: DatasetSource;
+    } | null>;
+    deleteDataset: (datasetId: string) => Promise<void>;
+    listDatasets: () => Promise<{
+        datasetId: string;
+        datasetSchema: DatasetSchema;
+        datasetSource?: DatasetSource;
+    }[]>;
+}

package/dist/cjs/types/adapters/index.d.ts

@@ -0,0 +1,2 @@
+export * from './QueryAdapter';
+export * from './StorageAdapter';

package/dist/{types/QueryDSL → cjs/types/dsl}/OrderBy.d.ts

@@ -1,4 +1,4 @@
 export type OrderBy<T> = Array<{
-    field: keyof T;
+    field: string | keyof T;
     order?: 'asc' | 'desc';
 }>;

package/dist/{types/QueryDSL → cjs/types/dsl}/Select.d.ts

@@ -1,4 +1,4 @@
-export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max';
+export type AggregateFunction = 'count' | 'sum' | 'avg' | 'min' | 'max' | 'quantile';
 export type SelectItem<T> = {
     field: keyof T;
     alias?: string;

package/dist/{types → cjs/types}/index.d.ts

@@ -1,4 +1,5 @@
 export * from './DataSet';
 export * from './DataSource';
 export * from './QueryResult';
-export * from './QueryDSL';
+export * from './dsl';
+export * from './adapters';

package/dist/{vquery.d.ts → cjs/vquery-browser.d.ts}

@@ -1,10 +1,10 @@
 import { Dataset } from './dataset/dataset';
 import { RawDatasetSource, DatasetColumn } from './types';
 export declare class VQuery {
-    private duckDB;
-    private indexedDB;
+    private queryAdapter;
+    private storageAdapter;
     private isInitialized;
-    constructor(dbName?: string);
+    constructor();
     private checkInitialized;
     private checkDatasetExists;
     createDataset(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
@@ -14,8 +14,8 @@ export declare class VQuery {
     hasDataset(datasetId: string): Promise<boolean>;
     listDatasets(): Promise<{
         datasetId: string;
-        dataSource?: import("./types").DatasetSource;
         datasetSchema: import("./types").DatasetSchema;
+        datasetSource?: import("./types").DatasetSource;
     }[]>;
     close(): Promise<void>;
 }

package/dist/cjs/vquery-node.d.ts

@@ -0,0 +1,21 @@
+import { Dataset } from './dataset/dataset';
+import { RawDatasetSource, DatasetColumn } from './types';
+export declare class VQuery {
+    private queryAdapter;
+    private storageAdapter;
+    private isInitialized;
+    constructor();
+    private checkInitialized;
+    private checkDatasetExists;
+    createDataset(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
+    updateDatasetSource(datasetId: string, columns?: DatasetColumn[], rawDatasetSource?: RawDatasetSource): Promise<void>;
+    dropDataset(datasetId: string): Promise<void>;
+    connectDataset(datasetId: string, temporaryColumns?: DatasetColumn[], temporaryRawDatasetSource?: RawDatasetSource): Promise<Dataset>;
+    hasDataset(datasetId: string): Promise<boolean>;
+    listDatasets(): Promise<{
+        datasetId: string;
+        datasetSchema: import("./types").DatasetSchema;
+        datasetSource?: import("./types").DatasetSource;
+    }[]>;
+    close(): Promise<void>;
+}

package/dist/esm/adapters/index.d.ts

@@ -0,0 +1 @@
+export { IndexedDBAdapter, InMemoryAdapter } from './storage-adapter';

package/dist/esm/adapters/query-adapter/duckdbNodeAdapter.d.ts

@@ -0,0 +1,14 @@
+import { QueryAdapter } from '../../types';
+export declare class DuckDBNodeQueryAdapter implements QueryAdapter {
+    private bindings;
+    private connection;
+    constructor();
+    open: () => Promise<void>;
+    close: () => Promise<void>;
+    writeFile: <T extends Blob>(fileName: string, source: T) => Promise<void>;
+    query: (sql: string) => Promise<{
+        dataset: any[];
+        table: any;
+    }>;
+    getSchema: (fileName: string) => Promise<any>;
+}