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

package/dist/api.d.ts

@@ -2,8 +2,9 @@ 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>;
@@ -13,10 +14,8 @@ export interface HyperDBClient {
     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>;
@@ -28,24 +27,23 @@ export interface ArrowInsertOptions {
     readonly schema?: string;
     readonly create?: boolean;
 }
-export interface ExternalFileRegistration {
-    readonly name: string;
-    readonly url: string;
-    readonly size: number;
+export type MountAccessMode = 'read' | 'readwrite';
+export interface MountOptions {
+    readonly path: string;
+    readonly mode?: MountAccessMode;
 }
-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 type QueryMetricValue = null | boolean | number | string | readonly QueryMetricValue[] | {
@@ -88,22 +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>;
-    registerExternalFile(...args: ExternalFileArgs): Promise<string>;
-    removeExternalRegistration(path: string): Promise<void>;
-    protected registerExternalDirectorySource(source: unknown, mode: ExternalDirectoryMode): Promise<string>;
+    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;

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;
@@ -14,6 +14,7 @@ export interface BrowserClientOptions {
     /** 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;
@@ -32,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, storagePath?: string): 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 {};