@visactor/vquery 0.2.3 → 0.2.6

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

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

package/dist/browser/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>;
+}

package/dist/browser/esm/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/browser/esm/adapters/storage-adapter/index.d.ts

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

package/dist/{db/indexedDb.d.ts → browser/esm/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/browser/esm/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/browser/esm/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/{index.js → browser/esm/browser.js}

@@ -142,16 +142,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;
+        this.queryAdapter = duckDB;
+        this.storageAdapter = indexedDB1;
         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;
@@ -174,11 +174,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) {
@@ -187,7 +187,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,
@@ -199,79 +199,111 @@ 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;
     }
 }
-class DuckDB {
-    db = null;
-    connection = null;
-    constructor(){}
-    init = async ()=>{
-        const MANUAL_BUNDLES = {
-            mvp: {
-                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm', import.meta.url).href,
-                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-mvp.worker.js', import.meta.url).toString()
-            },
-            eh: {
-                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm', import.meta.url).href,
-                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-eh.worker.js', import.meta.url).toString()
-            }
-        };
-        const bundle = await 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 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;
-        }
-    };
-    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());
+const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
+const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
+const isBase64Url = (url)=>url.startsWith('data:');
+class DatasetSourceBuilder {
+    type;
+    value;
+    constructor(raw){
+        this.type = raw.type;
+        this.value = raw.rawDataset;
+    }
+    static from(raw) {
+        return new DatasetSourceBuilder(raw);
+    }
+    async build() {
+        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
         return {
-            dataset,
-            table
+            type: this.type,
+            blob: blob
         };
-    };
-    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());
-    };
+    }
+    static async convertToBlob(type, value) {
+        if (value instanceof Blob) return value;
+        const convertCsvToBlob = (csvSource)=>{
+            if (csvSource instanceof ArrayBuffer) return new Blob([
+                csvSource
+            ], {
+                type: 'text/csv'
+            });
+            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
+            return new Blob([
+                JSON.stringify(csvSource)
+            ], {
+                type: 'text/csv'
+            });
+        };
+        const convertJsonToBlob = (jsonSource)=>{
+            if (jsonSource instanceof ArrayBuffer) return new Blob([
+                jsonSource
+            ], {
+                type: 'application/json'
+            });
+            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
+            return new Blob([
+                JSON.stringify(jsonSource)
+            ], {
+                type: 'application/json'
+            });
+        };
+        const convertParquetToBlob = (parquetSource)=>{
+            if (parquetSource instanceof ArrayBuffer) return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
+            return new Blob([
+                parquetSource
+            ], {
+                type: 'application/parquet'
+            });
+        };
+        const convertXlsxToBlob = (xlsxSource)=>{
+            if (xlsxSource instanceof ArrayBuffer) return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
+            return new Blob([
+                xlsxSource
+            ], {
+                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+            });
+        };
+        switch(type){
+            case 'csv':
+                return convertCsvToBlob(value);
+            case 'json':
+                return convertJsonToBlob(value);
+            case 'xlsx':
+                return convertXlsxToBlob(value);
+            case 'parquet':
+                return convertParquetToBlob(value);
+            default:
+                return new Blob([
+                    value
+                ]);
+        }
+    }
+    static async fetchBlob(url) {
+        const response = await fetch(url);
+        return await response.blob();
+    }
 }
-class IndexedDB {
+class IndexedDBAdapter {
     db = null;
     dbName;
     datasetStoreName = 'vqueryDatasets';
-    constructor(dbName){
+    constructor(dbName = 'vquery'){
         this.dbName = dbName;
     }
     open = ()=>new Promise((resolve, reject)=>{
@@ -290,7 +322,7 @@ class IndexedDB {
                 reject(event.target.error);
             };
         });
-    close = ()=>{
+    close = async ()=>{
         if (this.db) {
             this.db.close();
             this.db = null;
@@ -359,112 +391,80 @@ class IndexedDB {
             };
         });
 }
-const isUrl = (url)=>isHttpUrl(url) || isBase64Url(url);
-const isHttpUrl = (url)=>url.startsWith('http://') || url.startsWith('https://');
-const isBase64Url = (url)=>url.startsWith('data:');
-class DatasetSourceBuilder {
-    type;
-    value;
-    constructor(raw){
-        this.type = raw.type;
-        this.value = raw.rawDataset;
-    }
-    static from(raw) {
-        return new DatasetSourceBuilder(raw);
-    }
-    async build() {
-        const blob = await DatasetSourceBuilder.convertToBlob(this.type, this.value);
-        return {
-            type: this.type,
-            blob: blob
-        };
-    }
-    static async convertToBlob(type, value) {
-        if (value instanceof Blob) return value;
-        const convertCsvToBlob = (csvSource)=>{
-            if (csvSource instanceof ArrayBuffer) return new Blob([
-                csvSource
-            ], {
-                type: 'text/csv'
-            });
-            if ('string' == typeof csvSource && isUrl(csvSource)) return DatasetSourceBuilder.fetchBlob(csvSource);
-            return new Blob([
-                JSON.stringify(csvSource)
-            ], {
-                type: 'text/csv'
-            });
-        };
-        const convertJsonToBlob = (jsonSource)=>{
-            if (jsonSource instanceof ArrayBuffer) return new Blob([
-                jsonSource
-            ], {
-                type: 'application/json'
-            });
-            if ('string' == typeof jsonSource && isUrl(jsonSource)) return DatasetSourceBuilder.fetchBlob(jsonSource);
-            return new Blob([
-                JSON.stringify(jsonSource)
-            ], {
-                type: 'application/json'
-            });
-        };
-        const convertParquetToBlob = (parquetSource)=>{
-            if (parquetSource instanceof ArrayBuffer) return new Blob([
-                parquetSource
-            ], {
-                type: 'application/parquet'
-            });
-            if ('string' == typeof parquetSource && isUrl(parquetSource)) return DatasetSourceBuilder.fetchBlob(parquetSource);
-            return new Blob([
-                parquetSource
-            ], {
-                type: 'application/parquet'
-            });
-        };
-        const convertXlsxToBlob = (xlsxSource)=>{
-            if (xlsxSource instanceof ArrayBuffer) return new Blob([
-                xlsxSource
-            ], {
-                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-            });
-            if ('string' == typeof xlsxSource && isUrl(xlsxSource)) return DatasetSourceBuilder.fetchBlob(xlsxSource);
-            return new Blob([
-                xlsxSource
-            ], {
-                type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
-            });
+class DuckDBWebQueryAdapter {
+    db = null;
+    connection = null;
+    constructor(){}
+    open = async ()=>{
+        const MANUAL_BUNDLES = {
+            mvp: {
+                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm', import.meta.url).href,
+                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-mvp.worker.js', import.meta.url).toString()
+            },
+            eh: {
+                mainModule: new URL('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm', import.meta.url).href,
+                mainWorker: new URL('@duckdb/duckdb-wasm/dist/duckdb-browser-eh.worker.js', import.meta.url).toString()
+            }
         };
-        switch(type){
-            case 'csv':
-                return convertCsvToBlob(value);
-            case 'json':
-                return convertJsonToBlob(value);
-            case 'xlsx':
-                return convertXlsxToBlob(value);
-            case 'parquet':
-                return convertParquetToBlob(value);
-            default:
-                return new Blob([
-                    value
-                ]);
+        const bundle = await 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 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;
         }
-    }
-    static async fetchBlob(url) {
-        const response = await fetch(url);
-        return await response.blob();
-    }
+        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 VQuery {
-    duckDB;
-    indexedDB;
+    queryAdapter;
+    storageAdapter;
     isInitialized = false;
-    constructor(dbName = 'vquery'){
-        this.duckDB = new DuckDB();
-        this.indexedDB = new IndexedDB(dbName);
+    constructor(){
+        this.queryAdapter = new DuckDBWebQueryAdapter();
+        this.storageAdapter = new IndexedDBAdapter();
     }
     async checkInitialized() {
         if (!this.isInitialized) {
-            await this.duckDB.init();
-            await this.indexedDB.open();
+            await this.queryAdapter.open();
+            await this.storageAdapter.open();
             this.isInitialized = true;
         }
     }
@@ -480,7 +480,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();
@@ -491,33 +491,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();
     }
 }
 export { DatasetSourceBuilder, VQuery, convertDSLToSQL, isBase64Url, isHttpUrl, isUrl };

package/dist/{dataset → browser/esm/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.d.ts → browser/esm/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 → browser/esm/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/browser/esm/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/browser/esm/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/browser/esm/types/adapters/index.d.ts

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

package/dist/{types/QueryDSL → browser/esm/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 → browser/esm/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 → browser/esm/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>;
 }