@motherduck/wasm-client 0.6.2 → 0.6.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@motherduck/wasm-client",
-  "version": "0.6.2",
+  "version": "0.6.4",
   "description": "Client library for MotherDuck-enabled DuckDB powered by WebAssembly (WASM)",
   "browser": "index.js",
   "types": "types/index.d.ts",

package/types/DuckDBInstance.d.ts

@@ -1,3 +1,3 @@
-import { AsyncDuckDB } from '@duckdb/duckdb-wasm';
+import { AsyncDuckDB } from './duckdb-wasm';
 export declare function getDuckDBInstance(): Promise<AsyncDuckDB> | AsyncDuckDB | null;
 export declare function setDuckDBInstance(instance: Promise<AsyncDuckDB> | AsyncDuckDB): void;

package/types/MDConnection.d.ts

@@ -1,4 +1,4 @@
-import { AsyncPreparedStatement, ScriptTokens, TokenType } from '@duckdb/duckdb-wasm';
+import { AsyncPreparedStatement, ScriptTokens, TokenType } from './duckdb-wasm';
 import { MDConnectionParams } from './MDConnectionParams';
 import { MaterializedQueryResult, SafePrepareResult, SafeQueryResult, StreamingQueryResult } from './QueryTypes';
 export { ScriptTokens, TokenType };

package/types/MaterializedQueryTask.d.ts

@@ -1,4 +1,4 @@
-import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { AsyncDuckDBConnection } from './duckdb-wasm';
 import { MaterializedQueryResult } from './QueryTypes';
 import { Task } from './TaskSequencer';
 export declare class MaterializedQueryTask implements Task<MaterializedQueryResult> {

package/types/QueryTypes.d.ts

@@ -1,6 +1,6 @@
-import { AsyncPreparedStatement } from '@duckdb/duckdb-wasm';
-import { TypedTypeMap } from '@motherduck/duckdb-arrow';
-import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataReader } from '@motherduck/duckdb-data';
+import { AsyncPreparedStatement } from './duckdb-wasm';
+import { TypedTypeMap } from './motherduck/duckdb-arrow';
+import { AsyncDuckDBDataBatchIterator, DuckDBData, DuckDBDataReader } from './motherduck/duckdb-data';
 import { AsyncRecordBatchStreamReader, DataType } from 'apache-arrow';
 export interface MaterializedQueryResult {
     type: 'materialized';

package/types/StreamingQueryTask.d.ts

@@ -1,4 +1,4 @@
-import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { AsyncDuckDBConnection } from './duckdb-wasm';
 import { StreamingQueryResult } from './QueryTypes';
 import { Task } from './TaskSequencer';
 export declare class StreamingQueryTask implements Task<StreamingQueryResult> {

package/types/createDuckDbConnection.d.ts

@@ -1,3 +1,3 @@
-import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { AsyncDuckDBConnection } from './duckdb-wasm';
 import { MDConnectionParams } from './MDConnectionParams';
 export declare function createDuckDbConnection(params: MDConnectionParams): Promise<AsyncDuckDBConnection>;

package/types/duckdb-wasm/bindings/bindings_base.d.ts

@@ -0,0 +1,122 @@
+import { DuckDBModule, PThread } from './duckdb_module';
+import { DuckDBConfig } from './config';
+import { Logger } from '../log';
+import { InstantiationProgress } from './progress';
+import { DuckDBBindings } from './bindings_interface';
+import { DuckDBConnection } from './connection';
+import { DuckDBRuntime, DuckDBDataProtocol } from './runtime';
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from './insert_options';
+import { ScriptTokens } from './tokens';
+import { FileStatistics } from './file_stats';
+import { WebFile } from './web_file';
+import * as arrow from 'apache-arrow';
+declare global {
+    var DUCKDB_RUNTIME: any;
+}
+/** A DuckDB Feature */
+export declare enum DuckDBFeature {
+    WASM_EXCEPTIONS = 1,
+    WASM_THREADS = 2,
+    WASM_SIMD = 4,
+    WASM_BULK_MEMORY = 8,
+    EMIT_BIGINT = 16
+}
+/** The proxy for either the browser- order node-based DuckDB API */
+export declare abstract class DuckDBBindingsBase implements DuckDBBindings {
+    /** The logger */
+    protected readonly _logger: Logger;
+    /** Backend-dependent native-glue code for DuckDB */
+    protected readonly _runtime: DuckDBRuntime;
+    /** The instance */
+    protected _instance: DuckDBModule | null;
+    /** The loading promise */
+    protected _initPromise: Promise<void> | null;
+    /** The resolver for the open promise (called by onRuntimeInitialized) */
+    protected _initPromiseResolver: () => void;
+    /** The next UDF id */
+    protected _nextUDFId: number;
+    constructor(logger: Logger, runtime: DuckDBRuntime);
+    /** Get the logger */
+    get logger(): Logger;
+    /** Get the instance */
+    get mod(): DuckDBModule;
+    /** Get the instance */
+    get pthread(): PThread | null;
+    /** Instantiate the module */
+    protected abstract instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+    /** Instantiate the module */
+    protected onInstantiationProgress: ((p: InstantiationProgress) => void)[];
+    /** Instantiate the database */
+    instantiate(onProgress?: (progress: InstantiationProgress) => void): Promise<this>;
+    /** Open a database with a config */
+    open(config: DuckDBConfig): void;
+    /** Reset the database */
+    reset(): void;
+    /** Get the version */
+    getVersion(): string;
+    /** Get the feature flags */
+    getFeatureFlags(): number;
+    /** Tokenize a script */
+    tokenize(text: string): ScriptTokens;
+    /** Connect to database */
+    connect(): DuckDBConnection;
+    /** Disconnect from database */
+    disconnect(conn: number): void;
+    /** Send a query and return the full result */
+    runQuery(conn: number, text: string): Uint8Array;
+    /**
+     *  Start a pending query asynchronously.
+     *  This method returns either the arrow ipc schema or null.
+     *  On null, the query has to be executed using `pollPendingQuery` until that returns != null.
+     *  Results can then be fetched using `fetchQueryResults`
+     */
+    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    /** Poll a pending query */
+    pollPendingQuery(conn: number): Uint8Array | null;
+    /** Cancel a pending query */
+    cancelPendingQuery(conn: number): boolean;
+    /** Fetch query results */
+    fetchQueryResults(conn: number): Uint8Array;
+    /** Get table names */
+    getTableNames(conn: number, text: string): string[];
+    /** Create a scalar function */
+    createScalarFunction(conn: number, name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
+    /** Prepare a statement and return its identifier */
+    createPrepared(conn: number, text: string): number;
+    /** Close a prepared statement */
+    closePrepared(conn: number, statement: number): void;
+    /** Execute a prepared statement and return the full result */
+    runPrepared(conn: number, statement: number, params: any[]): Uint8Array;
+    /** Execute a prepared statement and stream the result */
+    sendPrepared(conn: number, statement: number, params: any[]): Uint8Array;
+    /** Insert record batches from an arrow ipc stream */
+    insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: ArrowInsertOptions): void;
+    /** Insert csv from path */
+    insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): void;
+    /** Insert json from path */
+    insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): void;
+    /** Glob file infos */
+    globFiles(path: string): WebFile[];
+    /** Register a file object URL */
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO?: boolean): void;
+    /** Register file text */
+    registerFileText(name: string, text: string): void;
+    /** Register a file buffer */
+    registerFileBuffer(name: string, buffer: Uint8Array): void;
+    /** Register a file object URL */
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
+    /** Drop file */
+    dropFile(name: string): void;
+    /** Drop files */
+    dropFiles(): void;
+    /** Flush all files */
+    flushFiles(): void;
+    /** Write a file to a path */
+    copyFileToPath(name: string, path: string): void;
+    /** Write a file to a buffer */
+    copyFileToBuffer(name: string): Uint8Array;
+    /** Enable tracking of file statistics */
+    collectFileStatistics(file: string, enable: boolean): void;
+    /** Export file statistics */
+    exportFileStatistics(file: string): FileStatistics;
+}

package/types/duckdb-wasm/bindings/bindings_browser_base.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="emscripten" />
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBBindingsBase } from './bindings_base';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+/** DuckDB bindings for the browser */
+export declare abstract class DuckDBBrowserBindings extends DuckDBBindingsBase {
+    /** The path of the wasm module */
+    protected readonly mainModuleURL: string;
+    /** The path of the pthread worker script */
+    protected readonly pthreadWorkerURL: string | null;
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModuleURL: string, pthreadWorkerURL: string | null);
+    /** Locate a file */
+    protected locateFile(path: string, prefix: string): string;
+    /** Instantiate the wasm module */
+    protected instantiateWasm(imports: any, success: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void): Emscripten.WebAssemblyExports;
+    protected abstract instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}

package/types/duckdb-wasm/bindings/bindings_browser_coi.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBBrowserBindings } from './bindings_browser_base';
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+/** DuckDB bindings for the browser */
+export declare class DuckDB extends DuckDBBrowserBindings {
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModuleURL: string, pthreadWorkerURL?: string | null);
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}
+export default DuckDB;

package/types/duckdb-wasm/bindings/bindings_browser_eh.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBBrowserBindings } from './bindings_browser_base';
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+/** DuckDB bindings for the browser */
+export declare class DuckDB extends DuckDBBrowserBindings {
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModuleURL: string, pthreadWorkerURL?: string | null);
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}
+export default DuckDB;

package/types/duckdb-wasm/bindings/bindings_browser_mvp.d.ts

@@ -0,0 +1,11 @@
+import { DuckDBBrowserBindings } from './bindings_browser_base';
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+/** DuckDB bindings for the browser */
+export declare class DuckDB extends DuckDBBrowserBindings {
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModuleURL: string, pthreadWorkerURL?: string | null);
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}

package/types/duckdb-wasm/bindings/bindings_interface.d.ts

@@ -0,0 +1,41 @@
+import { DuckDBConfig, DuckDBConnection, DuckDBDataProtocol, FileStatistics, InstantiationProgress } from '.';
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from './insert_options';
+import { ScriptTokens } from './tokens';
+import { WebFile } from './web_file';
+import * as arrow from 'apache-arrow';
+export interface DuckDBBindings {
+    open(config: DuckDBConfig): void;
+    reset(): void;
+    instantiate(onProgress: (p: InstantiationProgress) => void): Promise<this>;
+    getVersion(): string;
+    getFeatureFlags(): number;
+    tokenize(text: string): ScriptTokens;
+    connect(): DuckDBConnection;
+    disconnect(conn: number): void;
+    runQuery(conn: number, text: string): Uint8Array;
+    startPendingQuery(conn: number, text: string): Uint8Array | null;
+    pollPendingQuery(conn: number): Uint8Array | null;
+    cancelPendingQuery(conn: number): boolean;
+    fetchQueryResults(conn: number): Uint8Array;
+    getTableNames(conn: number, text: string): string[];
+    createPrepared(conn: number, text: string): number;
+    closePrepared(conn: number, statement: number): void;
+    runPrepared(conn: number, statement: number, params: any[]): Uint8Array;
+    sendPrepared(conn: number, statement: number, params: any[]): Uint8Array;
+    createScalarFunction(conn: number, name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
+    insertArrowFromIPCStream(conn: number, buffer: Uint8Array, options?: ArrowInsertOptions): void;
+    insertCSVFromPath(conn: number, path: string, options: CSVInsertOptions): void;
+    insertJSONFromPath(conn: number, path: string, options: JSONInsertOptions): void;
+    registerFileURL(name: string, url: string, proto: DuckDBDataProtocol, directIO: boolean): void;
+    registerFileText(name: string, text: string): void;
+    registerFileBuffer(name: string, buffer: Uint8Array): void;
+    registerFileHandle<HandleType>(name: string, handle: HandleType, protocol: DuckDBDataProtocol, directIO: boolean): void;
+    globFiles(path: string): WebFile[];
+    dropFile(name: string): void;
+    dropFiles(): void;
+    flushFiles(): void;
+    copyFileToPath(name: string, path: string): void;
+    copyFileToBuffer(name: string): Uint8Array;
+    collectFileStatistics(file: string, enable: boolean): void;
+    exportFileStatistics(file: string): FileStatistics;
+}

package/types/duckdb-wasm/bindings/bindings_node_base.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="emscripten" />
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBBindingsBase } from './bindings_base';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+declare global {
+    var DUCKDB_RUNTIME: any;
+}
+/** DuckDB bindings for node.js */
+export declare class DuckDBNodeBindings extends DuckDBBindingsBase {
+    /** The path of the wasm module */
+    protected readonly mainModulePath: string;
+    /** The path of the pthread worker script */
+    protected readonly pthreadWorkerPath: string | null;
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModulePath: string, pthreadWorkerPath: string | null);
+    /** Locate a file */
+    protected locateFile(path: string, prefix: string): string;
+    /** Instantiate the wasm module */
+    protected instantiateWasm(imports: any, success: (instance: WebAssembly.Instance, module: WebAssembly.Module) => void): Emscripten.WebAssemblyExports;
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}

package/types/duckdb-wasm/bindings/bindings_node_eh.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBNodeBindings } from './bindings_node_base.js';
+import { DuckDBRuntime } from './runtime';
+import { Logger } from '../log';
+/** DuckDB bindings for node.js */
+export declare class DuckDB extends DuckDBNodeBindings {
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModulePath: string, pthreadWorkerPath?: string | null);
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}
+export default DuckDB;

package/types/duckdb-wasm/bindings/bindings_node_mvp.d.ts

@@ -0,0 +1,12 @@
+import { DuckDBNodeBindings } from './bindings_node_base.js';
+import { Logger } from '../log.js';
+import { DuckDBModule } from './duckdb_module';
+import { DuckDBRuntime } from './runtime';
+/** DuckDB bindings for node.js */
+export declare class DuckDB extends DuckDBNodeBindings {
+    /** Constructor */
+    constructor(logger: Logger, runtime: DuckDBRuntime, mainModulePath: string, pthreadWorkerPath?: string | null);
+    /** Instantiate the bindings */
+    protected instantiateImpl(moduleOverrides: Partial<DuckDBModule>): Promise<DuckDBModule>;
+}
+export default DuckDB;

package/types/duckdb-wasm/bindings/config.d.ts

@@ -0,0 +1,62 @@
+export interface DuckDBQueryConfig {
+    /**
+     * The polling interval for queries
+     */
+    queryPollingInterval?: number;
+    /**
+     * Cast BigInt to Double?
+     */
+    castBigIntToDouble?: boolean;
+    /**
+     * Cast Timestamp to Date64?
+     */
+    castTimestampToDate?: boolean;
+    /**
+     * Cast Timestamp to Date64?
+     */
+    castDurationToTime64?: boolean;
+    /**
+     * Cast Decimal to Double?
+     */
+    castDecimalToDouble?: boolean;
+}
+export interface DuckDBFilesystemConfig {
+    /**
+     * Allow falling back to full HTTP reads if the server does not support range requests.
+     */
+    reliableHeadRequests?: boolean;
+    allowFullHTTPReads?: boolean;
+}
+export declare enum DuckDBAccessMode {
+    UNDEFINED = 0,
+    AUTOMATIC = 1,
+    READ_ONLY = 2,
+    READ_WRITE = 3
+}
+export interface DuckDBConfig {
+    /**
+     * The database path
+     */
+    path?: string;
+    /**
+     * The access mode
+     */
+    accessMode?: DuckDBAccessMode;
+    /**
+     * The maximum number of threads.
+     * Note that this will only work with cross-origin isolated sites since it requires SharedArrayBuffers.
+     */
+    maximumThreads?: number;
+    /**
+     * The query config
+     */
+    query?: DuckDBQueryConfig;
+    /**
+     * The filesystem config
+     */
+    filesystem?: DuckDBFilesystemConfig;
+    /**
+     * Whether to allow unsigned extensions
+     */
+    allowUnsignedExtensions?: boolean;
+}

package/types/duckdb-wasm/bindings/connection.d.ts

@@ -0,0 +1,74 @@
+import * as arrow from 'apache-arrow';
+import { DuckDBBindings } from './bindings_interface';
+import { CSVInsertOptions, JSONInsertOptions, ArrowInsertOptions } from './insert_options';
+/** A thin helper to bind the connection id and talk record batches */
+export declare class DuckDBConnection {
+    /** The bindings */
+    protected _bindings: DuckDBBindings;
+    /** The connection handle */
+    protected _conn: number;
+    /** Constructor */
+    constructor(bindings: DuckDBBindings, conn: number);
+    /** Close a connection */
+    close(): void;
+    /** Brave souls may use this function to consume the underlying connection id */
+    useUnsafe<R>(callback: (bindings: DuckDBBindings, conn: number) => R): R;
+    /** Run a query */
+    query<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): arrow.Table<T>;
+    /** Send a query */
+    send<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): Promise<arrow.RecordBatchStreamReader<T>>;
+    /** Cancel a query that was sent earlier */
+    cancelSent(): boolean;
+    /** Get table names */
+    getTableNames(query: string): string[];
+    /** Create a prepared statement */
+    prepare<T extends {
+        [key: string]: arrow.DataType;
+    } = any>(text: string): PreparedStatement;
+    /** Create a scalar function */
+    createScalarFunction(name: string, returns: arrow.DataType, func: (...args: any[]) => void): void;
+    /** Insert an arrow table */
+    insertArrowTable(table: arrow.Table, options: ArrowInsertOptions): void;
+    /** Insert an arrow table from an ipc stream */
+    insertArrowFromIPCStream(buffer: Uint8Array, options: ArrowInsertOptions): void;
+    /** Inesrt csv file from path */
+    insertCSVFromPath(path: string, options: CSVInsertOptions): void;
+    /** Insert json file from path */
+    insertJSONFromPath(path: string, options: JSONInsertOptions): void;
+}
+/** A result stream iterator */
+export declare class ResultStreamIterator implements Iterable<Uint8Array> {
+    protected bindings: DuckDBBindings;
+    protected conn: number;
+    protected header: Uint8Array;
+    /** First chunk? */
+    _first: boolean;
+    /** Reached end of stream? */
+    _depleted: boolean;
+    constructor(bindings: DuckDBBindings, conn: number, header: Uint8Array);
+    next(): IteratorResult<Uint8Array>;
+    [Symbol.iterator](): this;
+}
+/** A thin helper to bind the prepared statement id*/
+export declare class PreparedStatement<T extends {
+    [key: string]: arrow.DataType;
+} = any> {
+    /** The bindings */
+    protected readonly bindings: DuckDBBindings;
+    /** The connection id */
+    protected readonly connectionId: number;
+    /** The statement id */
+    protected readonly statementId: number;
+    /** Constructor */
+    constructor(bindings: DuckDBBindings, connectionId: number, statementId: number);
+    /** Close a prepared statement */
+    close(): void;
+    /** Run a prepared statement */
+    query(...params: any[]): arrow.Table<T>;
+    /** Send a prepared statement */
+    send(...params: any[]): arrow.RecordBatchStreamReader<T>;
+}

package/types/duckdb-wasm/bindings/duckdb_module.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="emscripten" />
+export interface PThread {
+    unusedWorkers: Worker[];
+    runningWorkers: Worker[];
+}
+export interface DuckDBModule extends EmscriptenModule {
+    stackSave: typeof stackSave;
+    stackAlloc: typeof stackAlloc;
+    stackRestore: typeof stackRestore;
+    ccall: typeof ccall;
+    PThread: PThread;
+}

package/types/duckdb-wasm/bindings/file_stats.d.ts

@@ -0,0 +1,36 @@
+export interface FileBlockStatistics {
+    /** The file reads cold */
+    file_reads_cold: number;
+    /** The file reads aheads */
+    file_reads_ahead: number;
+    /** The file reads cached */
+    file_reads_cached: number;
+    /** The file writes */
+    file_writes: number;
+    /** The page accesses */
+    page_accesses: number;
+    /** The page loads */
+    page_loads: number;
+}
+/** The file block statistics */
+export declare class FileStatistics {
+    /** The cold file reads */
+    totalFileReadsCold: number;
+    /** The file readaheads */
+    totalFileReadsAhead: number;
+    /** The cached file reads */
+    totalFileReadsCached: number;
+    /** The file writes */
+    totalFileWrites: number;
+    /** The page accesses */
+    totalPageAccesses: number;
+    /** The page loads */
+    totalPageLoads: number;
+    /** The blocks */
+    blockSize: number;
+    /** The blocks */
+    blockStats: Uint8Array;
+    constructor(u8array: Uint8Array);
+    /** The block stats */
+    getBlockStats(index: number, out?: FileBlockStatistics): FileBlockStatistics;
+}

package/types/duckdb-wasm/bindings/index.d.ts

@@ -0,0 +1,11 @@
+export * from './bindings_interface';
+export * from './bindings_base';
+export * from './config';
+export * from './connection';
+export * from './duckdb_module';
+export * from './file_stats';
+export * from './runtime';
+export * from './insert_options';
+export * from './progress';
+export * from './tokens';
+export * from './web_file';

package/types/duckdb-wasm/bindings/insert_options.d.ts

@@ -0,0 +1,38 @@
+import * as arrow from 'apache-arrow';
+import { SQLField } from '../json_typedef';
+export declare enum JSONTableShape {
+    ROW_ARRAY = "row-array",
+    COLUMN_OBJECT = "column-object"
+}
+export interface JSONInsertOptions {
+    name: string;
+    schema?: string;
+    create?: boolean;
+    shape?: JSONTableShape;
+    columns?: {
+        [key: string]: arrow.DataType;
+    };
+    columnsFlat?: SQLField[];
+}
+export interface CSVInsertOptions {
+    name: string;
+    schema?: string;
+    create?: boolean;
+    header?: boolean;
+    delimiter?: string;
+    quote?: string;
+    escape?: string;
+    skip?: number;
+    detect?: boolean;
+    dateFormat?: string;
+    timestampFormat?: string;
+    columns?: {
+        [key: string]: arrow.DataType;
+    };
+    columnsFlat?: SQLField[];
+}
+export interface ArrowInsertOptions {
+    name: string;
+    schema?: string;
+    create?: boolean;
+}

package/types/duckdb-wasm/bindings/progress.d.ts

@@ -0,0 +1,9 @@
+/** An instantiation progress */
+export interface InstantiationProgress {
+    startedAt: Date;
+    updatedAt: Date;
+    bytesTotal: number;
+    bytesLoaded: number;
+}
+/** An instantiation progress handler */
+export type InstantiationProgressHandler = (p: InstantiationProgress) => void;