@visactor/vquery 0.2.3 → 0.2.6

package/dist/node/cjs/types/DataSource.d.ts

@@ -0,0 +1,11 @@
+export type TidyDatum = Record<string, number | string | null | boolean | undefined>;
+export type DatasetSourceType = 'csv' | 'json' | 'xlsx' | 'parquet';
+export type DatasetSourceValue = string | ArrayBuffer | Blob | TidyDatum[];
+export interface DatasetSource {
+    type: DatasetSourceType;
+    blob: Blob;
+}
+export interface RawDatasetSource {
+    type: DatasetSourceType;
+    rawDataset: DatasetSourceValue;
+}

package/dist/node/cjs/types/QueryResult.d.ts

@@ -0,0 +1 @@
+export type QueryResult = any;

package/dist/node/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/node/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/node/cjs/types/adapters/index.d.ts

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

package/dist/node/cjs/types/dsl/GroupBy.d.ts

@@ -0,0 +1 @@
+export type GroupBy<T> = Array<keyof T>;

package/dist/node/cjs/types/dsl/OrderBy.d.ts

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

package/dist/node/cjs/types/dsl/QueryDSL.d.ts

@@ -0,0 +1,12 @@
+import { GroupBy } from './GroupBy';
+import { OrderBy } from './OrderBy';
+import { Select } from './Select';
+import { Where } from './Where';
+export interface QueryDSL<Table> {
+    select: Select<Table>;
+    where?: Where<Table>;
+    groupBy?: GroupBy<Table>;
+    orderBy?: OrderBy<Table>;
+    limit?: number;
+}
+export type VQueryDSL<Table = Record<string, unknown>> = QueryDSL<Table>;

package/dist/node/cjs/types/dsl/Select.d.ts

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

package/dist/node/cjs/types/dsl/Where.d.ts

@@ -0,0 +1,24 @@
+export type Where<T> = WhereGroup<T>;
+export type WhereGroup<T> = {
+    op: 'and' | 'or';
+    conditions: Array<WhereClause<T>>;
+};
+export type WhereClause<T> = WhereLeaf<T> | WhereGroup<T>;
+export type WhereLeaf<T> = {
+    [K in keyof T]: {
+        [O in Operator]: {
+            field: K;
+            op: O;
+        } & (O extends 'is null' | 'is not null' ? {
+            value?: never;
+        } : O extends 'in' | 'not in' ? {
+            value: T[K] | T[K][];
+        } : O extends 'between' | 'not between' ? {
+            value: [T[K], T[K]];
+        } : {
+            value: T[K];
+        });
+    }[Operator];
+}[keyof T];
+type Operator = '=' | '!=' | '>' | '>=' | '<' | '<=' | 'like' | 'not like' | 'ilike' | 'not ilike' | 'in' | 'not in' | 'between' | 'not between' | 'is null' | 'is not null';
+export {};

package/dist/node/cjs/types/dsl/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/node/cjs/types/dsl/index.d.ts

@@ -0,0 +1,5 @@
+export type { QueryDSL, VQueryDSL } from './QueryDSL';
+export type { GroupBy } from './GroupBy';
+export type { OrderBy } from './OrderBy';
+export type { Select } from './Select';
+export type { Where, WhereClause, WhereLeaf, WhereGroup } from './Where';

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

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

package/dist/node/cjs/utils/index.d.ts

@@ -0,0 +1 @@
+export { isUrl, isHttpUrl, isBase64Url } from './url';

package/dist/node/cjs/utils/url.d.ts

@@ -0,0 +1,3 @@
+export declare const isUrl: (url: string) => boolean;
+export declare const isHttpUrl: (url: string) => boolean;
+export declare const isBase64Url: (url: string) => boolean;

package/dist/node/cjs/vquery-browser.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/node/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/node/esm/adapters/index.d.ts

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

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

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

package/dist/node/esm/adapters/storage-adapter/indexeddbAdapter.d.ts

@@ -0,0 +1,21 @@
+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);
+    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<{
+        datasetId: string;
+        dataSource?: DatasetSource;
+        datasetSchema: DatasetSchema;
+    }[]>;
+}

package/dist/node/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/node/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/node/esm/data-source-builder/dataSourceBuilder.d.ts

@@ -0,0 +1,16 @@
+import { DatasetSourceType, RawDatasetSource } from '../types';
+export declare class DatasetSourceBuilder {
+    private type;
+    private value;
+    constructor(raw: RawDatasetSource);
+    static from(raw: RawDatasetSource): DatasetSourceBuilder;
+    build(): Promise<{
+        type: DatasetSourceType;
+        blob: Blob;
+    }>;
+    /**
+     * 将不同类型的数据转换为Blob
+     */
+    private static convertToBlob;
+    private static fetchBlob;
+}

package/dist/node/esm/data-source-builder/index.d.ts

@@ -0,0 +1 @@
+export { DatasetSourceBuilder } from './dataSourceBuilder';

package/dist/node/esm/dataset/dataset.d.ts

@@ -0,0 +1,30 @@
+import { DatasetColumn, DatasetSource, QueryDSL } from '../types';
+import { QueryAdapter, StorageAdapter } from '../types';
+export declare class Dataset {
+    private queryAdapter;
+    private storageAdapter;
+    private _datasetId;
+    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<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        dataset: any[];
+        table: any;
+    }>;
+    queryBySQL(sql: string): Promise<{
+        performance: {
+            startAt: string;
+            endAt: string;
+            duration: number;
+        };
+        dataset: any[];
+        table: any;
+    }>;
+    disconnect(): Promise<void>;
+    get datasetId(): string;
+}

package/dist/node/esm/dataset/index.d.ts

@@ -0,0 +1,2 @@
+export { Dataset } from './dataset';
+export { convertDSLToSQL } from '../sql-builder';

package/dist/node/esm/node.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-node';