@visactor/vquery 0.2.5 → 0.2.6

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';

package/dist/node/esm/node.js

@@ -0,0 +1,476 @@
+import { DummyDriver, Kysely, PostgresAdapter, PostgresQueryCompiler, sql as external_kysely_sql } from "kysely";
+import { ConsoleLogger, NODE_RUNTIME, createDuckDB } from "@duckdb/duckdb-wasm/blocking";
+import { createRequire } from "node:module";
+class PostgresDialect {
+    createDriver() {
+        return new DummyDriver();
+    }
+    createQueryCompiler() {
+        return new PostgresQueryCompiler();
+    }
+    createAdapter() {
+        return new PostgresAdapter();
+    }
+    createIntrospector(db) {
+        class NullIntrospector {
+            async getSchemas() {
+                return [];
+            }
+            async getTables(options) {
+                options?.withInternalKyselyTables;
+                return [];
+            }
+            async getMetadata(options) {
+                options?.withInternalKyselyTables;
+                return {
+                    tables: []
+                };
+            }
+        }
+        return new NullIntrospector();
+    }
+}
+const isSelectItem = (item)=>'object' == typeof item && 'field' in item;
+const escapeValue = (value)=>{
+    if (null === value) return 'null';
+    if ('string' == typeof value) return `'${value.replace(/'/g, "''")}'`;
+    if ('number' == typeof value) return `${value}`;
+    if ('boolean' == typeof value) return value ? 'TRUE' : 'FALSE';
+    return `'${String(value).replace(/'/g, "''")}'`;
+};
+const inlineParameters = (sql, params)=>{
+    if (0 === params.length) return sql;
+    if (sql.includes('?')) {
+        let out = sql;
+        for (const p of params)out = out.replace(/\?/, escapeValue(p));
+        return out;
+    }
+    if (/\$\d+/.test(sql)) return sql.replace(/\$(\d+)/g, (_, idx)=>{
+        const i = Number(idx) - 1;
+        const v = params[i];
+        return escapeValue(v);
+    });
+    return sql;
+};
+const applyWhere = (where)=>{
+    const toRaw = (w)=>{
+        if ('op' in w && 'conditions' in w) {
+            const parts = w.conditions.map((c)=>toRaw(c));
+            const sep = external_kysely_sql` ${external_kysely_sql.raw(w.op)} `;
+            return external_kysely_sql`(${external_kysely_sql.join(parts, sep)})`;
+        }
+        const leaf = w;
+        const field = leaf.field;
+        const value = leaf.value;
+        switch(leaf.op){
+            case 'is null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is null`;
+            case 'is not null':
+                return external_kysely_sql`${external_kysely_sql.ref(field)} is not null`;
+            case 'in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'not in':
+                {
+                    const items = Array.isArray(value) ? value : [
+                        value
+                    ];
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} in (${external_kysely_sql.join(items.map((v)=>external_kysely_sql.val(v)))})`;
+                }
+            case 'between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`${external_kysely_sql.ref(field)} between (${external_kysely_sql.val(a)}, ${external_kysely_sql.val(b)})`;
+                }
+            case 'not between':
+                {
+                    const [a, b] = value;
+                    return external_kysely_sql`not ${external_kysely_sql.ref(field)} between (${external_kysely_sql.val(a)}, ${external_kysely_sql.val(b)})`;
+                }
+            default:
+                return external_kysely_sql`${external_kysely_sql.ref(field)} ${external_kysely_sql.raw(leaf.op)} ${external_kysely_sql.val(value)}`;
+        }
+    };
+    return toRaw(where);
+};
+const applyGroupBy = (qb, fields)=>{
+    if (fields && fields.length > 0) {
+        const exprs = fields.map((f)=>external_kysely_sql.id(f));
+        qb = qb.groupBy(exprs);
+    }
+    return qb;
+};
+const applyLimit = (qb, limit)=>{
+    if (limit && 'number' == typeof limit) qb = qb.limit(limit);
+    return qb;
+};
+const convertDSLToSQL = (dsl, tableName)=>{
+    const db = new Kysely({
+        dialect: new PostgresDialect()
+    });
+    let qb = db.selectFrom(tableName);
+    qb = dsl.select && dsl.select.length > 0 ? qb.select((eb)=>dsl.select.map((item)=>{
+            if (isSelectItem(item)) {
+                const field = item.field;
+                if (item.func) {
+                    const alias = item.alias ?? field;
+                    switch(item.func){
+                        case 'avg':
+                            return eb.fn.avg(field).as(alias);
+                        case 'sum':
+                            return eb.fn.sum(field).as(alias);
+                        case 'min':
+                            return eb.fn.min(field).as(alias);
+                        case 'max':
+                            return eb.fn.max(field).as(alias);
+                        case 'count':
+                            return eb.fn.count(field).as(alias);
+                    }
+                }
+                return item.alias ? eb.ref(field).as(item.alias) : field;
+            }
+            return item;
+        })) : qb.selectAll();
+    if (dsl.where) qb = qb.where(applyWhere(dsl.where));
+    qb = applyGroupBy(qb, dsl.groupBy);
+    if (dsl.orderBy && dsl.orderBy.length > 0) for (const o of dsl.orderBy)qb = qb.orderBy(o.field, o.order ?? 'asc');
+    qb = applyLimit(qb, dsl.limit);
+    const compiled = qb.compile();
+    return inlineParameters(compiled.sql, compiled.parameters);
+};
+class Dataset {
+    queryAdapter;
+    storageAdapter;
+    _datasetId;
+    constructor(duckDB, indexedDB, datasetId){
+        this.queryAdapter = duckDB;
+        this.storageAdapter = indexedDB;
+        this._datasetId = datasetId;
+    }
+    async init(temporaryColumns, temporaryDatasetSource) {
+        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;
+        if (columns.length > 0 && datasetSource) await this.createOrReplaceView(columns, datasetSource);
+    }
+    async createOrReplaceView(columns, datasetSource) {
+        const readFunctionMap = {
+            csv: 'read_csv_auto',
+            json: 'read_json_auto',
+            xlsx: 'read_excel',
+            parquet: 'read_parquet'
+        };
+        const dataTypeMap = {
+            number: 'DOUBLE',
+            string: 'VARCHAR',
+            date: 'DATE',
+            datetime: 'TIMESTAMP',
+            timestamp: 'TIMESTAMP'
+        };
+        if (datasetSource) {
+            const readFunction = readFunctionMap[datasetSource.type];
+            if (!readFunction) throw new Error(`Unsupported dataSource type: ${datasetSource.type}`);
+            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.queryAdapter.query(createViewSql);
+        }
+    }
+    async query(queryDSL) {
+        const sql = convertDSLToSQL(queryDSL, this.datasetId);
+        return this.queryBySQL(sql);
+    }
+    async queryBySQL(sql) {
+        const start = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        const result = await this.queryAdapter.query(sql);
+        const end = performance?.now?.()?.toFixed(3) ?? Date.now().toFixed(3);
+        return {
+            ...result,
+            performance: {
+                startAt: start,
+                endAt: end,
+                duration: Number(end) - Number(start)
+            }
+        };
+    }
+    async disconnect() {
+        await this.queryAdapter.query(`DROP VIEW IF EXISTS "${this._datasetId}"`);
+    }
+    get datasetId() {
+        return this._datasetId;
+    }
+}
+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'
+            });
+        };
+        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 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);
+            }
+        });
+}
+class DuckDBNodeQueryAdapter {
+    bindings = null;
+    connection = null;
+    constructor(){}
+    open = async ()=>{
+        const require = createRequire(import.meta.url);
+        const MANUAL_BUNDLES = {
+            mvp: {
+                mainModule: require.resolve('@duckdb/duckdb-wasm/dist/duckdb-mvp.wasm'),
+                mainWorker: ''
+            },
+            eh: {
+                mainModule: require.resolve('@duckdb/duckdb-wasm/dist/duckdb-eh.wasm'),
+                mainWorker: ''
+            }
+        };
+        const logger = new ConsoleLogger();
+        this.bindings = await createDuckDB(MANUAL_BUNDLES, logger, 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 {
+    queryAdapter;
+    storageAdapter;
+    isInitialized = false;
+    constructor(){
+        this.queryAdapter = new DuckDBNodeQueryAdapter();
+        this.storageAdapter = new InMemoryAdapter();
+    }
+    async checkInitialized() {
+        if (!this.isInitialized) {
+            await this.queryAdapter.open();
+            await this.storageAdapter.open();
+            this.isInitialized = true;
+        }
+    }
+    async checkDatasetExists(datasetId) {
+        if (!await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} not exists, please create it first`);
+    }
+    async createDataset(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        if (await this.hasDataset(datasetId)) throw new Error(`dataset ${datasetId} already exists`);
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.storageAdapter.writeDataset(datasetId, datasetSchema, datasetSource);
+    }
+    async updateDatasetSource(datasetId, columns = [], rawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        const datasetSource = rawDatasetSource ? await DatasetSourceBuilder.from(rawDatasetSource).build() : void 0;
+        const datasetSchema = {
+            datasetId,
+            datasetAlias: datasetId,
+            columns: columns
+        };
+        await this.storageAdapter.writeDataset(datasetId, datasetSchema, datasetSource);
+    }
+    async dropDataset(datasetId) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(datasetId);
+        await this.storageAdapter.deleteDataset(datasetId);
+    }
+    async connectDataset(datasetId, temporaryColumns, temporaryRawDatasetSource) {
+        await this.checkInitialized();
+        await this.checkDatasetExists(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.storageAdapter.listDatasets();
+        return datasets.some((item)=>item.datasetId === datasetId);
+    }
+    async listDatasets() {
+        await this.checkInitialized();
+        return this.storageAdapter.listDatasets();
+    }
+    async close() {
+        await this.checkInitialized();
+        await this.queryAdapter.close();
+        await this.storageAdapter.close();
+    }
+}
+export { DatasetSourceBuilder, VQuery, convertDSLToSQL, isBase64Url, isHttpUrl, isUrl };

package/dist/node/esm/sql-builder/builders/groupBy.d.ts

@@ -0,0 +1,2 @@
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyGroupBy: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, fields?: Array<string>) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/esm/sql-builder/builders/index.d.ts

@@ -0,0 +1,3 @@
+export { applyWhere } from './where';
+export { applyGroupBy } from './groupBy';
+export { applyLimit } from './limit';

package/dist/node/esm/sql-builder/builders/limit.d.ts

@@ -0,0 +1,2 @@
+import type { SelectQueryBuilder } from 'kysely';
+export declare const applyLimit: <DB, TB extends keyof DB & string, O>(qb: SelectQueryBuilder<DB, TB, O>, limit?: number) => SelectQueryBuilder<DB, TB, O>;

package/dist/node/esm/sql-builder/builders/where.d.ts

@@ -0,0 +1,3 @@
+import { Where, WhereClause } from '../../types';
+import type { RawBuilder } from 'kysely';
+export declare const applyWhere: <T>(where: Where<T> | WhereClause<T>) => RawBuilder<boolean>;

package/dist/node/esm/sql-builder/compile/index.d.ts

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

package/dist/node/esm/sql-builder/compile/inlineParameters.d.ts

@@ -0,0 +1 @@
+export declare const inlineParameters: (sql: string, params: readonly unknown[]) => string;

package/dist/node/esm/sql-builder/dialect/index.d.ts

@@ -0,0 +1 @@
+export { PostgresDialect } from './postgresDialect';

package/dist/node/esm/sql-builder/dialect/postgresDialect.d.ts

@@ -0,0 +1,11 @@
+import { Dialect, DummyDriver } from 'kysely';
+import { PostgresQueryCompiler } from 'kysely';
+import { PostgresAdapter } from 'kysely';
+import { Kysely } from 'kysely';
+import type { DatabaseIntrospector } from 'kysely';
+export declare class PostgresDialect implements Dialect {
+    createDriver(): DummyDriver;
+    createQueryCompiler(): PostgresQueryCompiler;
+    createAdapter(): PostgresAdapter;
+    createIntrospector<DB = unknown>(db: Kysely<DB>): DatabaseIntrospector;
+}

package/dist/node/esm/sql-builder/dslToSQL.d.ts

@@ -0,0 +1,2 @@
+import { QueryDSL } from '../types';
+export declare const convertDSLToSQL: <T, TableName extends string>(dsl: QueryDSL<T>, tableName: TableName) => string;

package/dist/node/esm/sql-builder/index.d.ts

@@ -0,0 +1 @@
+export { convertDSLToSQL } from './dslToSQL';