hyperdb-wasm 0.0.26862-dev.wasm.g8c0876f6 → 0.0.26978-dev.wasm.g29b852db

package/dist/api.d.ts

@@ -2,28 +2,20 @@ import { DataType, Table } from 'apache-arrow';
 import type { AsyncRecordBatchStreamReader, TypeMap } from 'apache-arrow';
 import type { HyperDBEngineClient } from './client.js';
 import type { BrowserClientOptions } from './browser.js';
-import type { WasmResult } from './protocol.js';
+import type { MountSource, WasmResult } from './protocol.js';
 import type { HyperDBErrorSource } from './protocol.js';
+import type { UnaryRpcHandler } from './protocol.js';
 export interface HyperDBClient {
     ready(): Promise<void>;
     initialize(settings: string): Promise<WasmResult>;
     connect(): Promise<WasmResult>;
     disconnect(connection: number): Promise<WasmResult>;
-    createDatabase(databaseName: string, persistent: boolean): Promise<WasmResult>;
-    openDatabase(databaseName: string): Promise<WasmResult>;
-    listDatabases(): Promise<WasmResult>;
-    checkpointDatabase(databaseName: string): Promise<WasmResult>;
-    dropDatabase(databaseName: string): Promise<WasmResult>;
-    attachDatabase(connection: number, databaseName: string, alias: string): Promise<WasmResult>;
-    detachDatabase(connection: number, alias: string): Promise<WasmResult>;
     startQuery(connection: number, sql: string): Promise<WasmResult>;
     insertArrowIPCFromPath(connection: number, path: string, name: string, schema: string | null, create: boolean, internal?: boolean): Promise<WasmResult>;
     createTemporaryFile(bytes: Uint8Array): Promise<WasmResult>;
     removeFile(path: string): Promise<WasmResult>;
-    registerExternalFile(path: string): Promise<WasmResult>;
-    registerExternalFile(name: string, url: string, size: number): Promise<WasmResult>;
-    registerExternalDirectory(handle: unknown, mode: 'read' | 'readwrite'): Promise<WasmResult>;
-    removeExternalRegistration(path: string): Promise<WasmResult>;
+    mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
+    unmount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;
@@ -35,33 +27,25 @@ export interface ArrowInsertOptions {
     readonly schema?: string;
     readonly create?: boolean;
 }
-export interface DatabaseCreateOptions {
-    readonly storage?: 'transient' | 'persistent';
+export type MountAccessMode = 'read' | 'readwrite';
+export interface MountOptions {
+    readonly path: string;
+    readonly mode?: MountAccessMode;
 }
-export interface ExternalFileRegistration {
-    readonly name: string;
-    readonly url: string;
-    readonly size: number;
-}
-export type ExternalDirectoryMode = 'read' | 'readwrite';
-export interface ExternalDirectoryRegistrationOptions {
-    readonly mode?: ExternalDirectoryMode;
+export interface MountedResource {
+    readonly path: string;
+    close(): Promise<void>;
 }
-type BrowserExternalFileArguments = readonly [name: string, url: string, size: number];
-type NodeExternalFileArguments = readonly [path: string];
-export type ExternalFileArguments = BrowserExternalFileArguments | NodeExternalFileArguments;
+export declare function validateMountPath(path: unknown): asserts path is string;
 export type HyperDBSettingValue = string | number | boolean | null | readonly HyperDBSettingValue[] | {
     readonly [key: string]: HyperDBSettingValue;
 };
 export type HyperDBSettings = Readonly<Record<string, HyperDBSettingValue>>;
 export interface HyperDBCreateOptions {
     readonly settings?: HyperDBSettings;
+    readonly unaryRpc?: UnaryRpcHandler;
 }
 export type BrowserCreateOptions = BrowserClientOptions & HyperDBCreateOptions;
-export interface DatabaseMetadata {
-    readonly name: string;
-    readonly storage: 'transient' | 'persistent';
-}
 export type QueryMetricValue = null | boolean | number | string | readonly QueryMetricValue[] | {
     readonly [key: string]: QueryMetricValue;
 };
@@ -102,27 +86,22 @@ export declare class HyperDBError extends Error {
     constructor(message: string, sqlState: string, errorSource: HyperDBErrorSource, detail?: string, hint?: string);
 }
 declare function initializeHyperDB(client: HyperDBClient, settings: HyperDBSettings | undefined): Promise<void>;
-export declare class HyperDB<ExternalFileArgs extends ExternalFileArguments = BrowserExternalFileArguments> {
+export declare class HyperDB {
     protected readonly client: HyperDBClient;
     private terminated;
     private termination;
     private activeDatabaseOperations;
     private readonly connections;
+    private readonly mountedResources;
     constructor(client: HyperDBClient);
     static create(options?: BrowserCreateOptions): Promise<HyperDB>;
     ready(): Promise<void>;
     connect(): Promise<HyperDBConnection>;
-    createDatabase(databaseName: string, options?: DatabaseCreateOptions): Promise<void>;
-    openDatabase(databaseName: string): Promise<void>;
-    listDatabases(): Promise<DatabaseMetadata[]>;
-    registerExternalFile(...args: ExternalFileArgs): Promise<string>;
-    removeExternalRegistration(path: string): Promise<void>;
-    protected registerExternalDirectorySource(source: unknown, mode: ExternalDirectoryMode): Promise<string>;
-    checkpointDatabase(databaseName: string): Promise<void>;
-    dropDatabase(databaseName: string): Promise<void>;
+    protected mountSource(source: MountSource, path: string, mode: MountAccessMode, cleanup?: () => void): Promise<MountedResource>;
     terminate(): Promise<void>;
     private ensureRunning;
     protected runDatabaseOperation<Result>(operation: () => Promise<Result>): Promise<Result>;
+    private unmount;
 }
 export declare class HyperDBConnection {
     private readonly client;
@@ -133,8 +112,6 @@ export declare class HyperDBConnection {
     private closing;
     constructor(client: HyperDBClient, connection: number, onClose?: () => void);
     close(): Promise<void>;
-    attachDatabase(databaseName: string, alias?: string): Promise<void>;
-    detachDatabase(alias: string): Promise<void>;
     sendIPC(sql: string): QueryResult<AsyncIterable<Uint8Array>>;
     queryIPC(sql: string): QueryResult<Promise<Uint8Array>>;
     send<T extends TypeMap = {

package/dist/browser.d.ts

@@ -1,5 +1,5 @@
 import { HyperDBEngineClient } from './client.js';
-import type { EngineRequest, SetupProgress, WorkerTransport } from './protocol.js';
+import type { SetupProgress, UnaryRpcHandler, WorkerRequest, WorkerTransport } from './protocol.js';
 type BrowserListener = (event: unknown) => void;
 export interface BrowserWorkerLike {
     postMessage(message: unknown, transfer: ArrayBuffer[]): void;
@@ -11,7 +11,10 @@ export interface BrowserClientOptions {
     readonly workerUrl?: string | URL;
     readonly engineUrl?: string | URL;
     readonly wasmUrl?: string | URL;
+    /** OPFS-relative directory mounted as the durable filesystem root. */
+    readonly storagePath?: string;
     readonly onSetupProgress?: (progress: SetupProgress) => void;
+    readonly unaryRpc?: UnaryRpcHandler;
 }
 type BrowserEnvironment = {
     readonly WebAssembly?: typeof WebAssembly;
@@ -30,12 +33,12 @@ export declare function assertBrowserSupport(environment?: BrowserEnvironment):
 export declare class BrowserWorker implements WorkerTransport {
     private readonly worker;
     constructor(worker: BrowserWorkerLike);
-    postMessage(message: EngineRequest, transfer?: readonly ArrayBuffer[]): void;
+    postMessage(message: WorkerRequest, transfer?: readonly ArrayBuffer[]): void;
     onMessage(listener: (message: unknown) => void): () => void;
     onError(listener: (error: Error) => void): () => void;
     onClose(): () => void;
     terminate(): void;
 }
-export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL, wasmUrl?: string | URL): URL;
+export declare function resolveBrowserWorkerUrl(workerUrl: string | URL, engineUrl: string | URL, wasmUrl?: string | URL, storagePath?: string, baseUrl?: string | URL): URL;
 export declare function createBrowserClient(options?: BrowserClientOptions): HyperDBEngineClient;
 export {};