hyperdb-wasm 0.0.27136-dev.wasm.g7153f5a4 → 0.0.27136-dev.wasm.gcf673716

package/dist/api.d.ts

@@ -12,6 +12,7 @@ export interface HyperDBClient {
     startQuery(connection: number, sql: string): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
+    refreshMount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;
@@ -28,6 +29,7 @@ export interface MountOptions {
 }
 export interface MountedResource {
     readonly path: string;
+    refresh(): Promise<void>;
     close(): Promise<void>;
 }
 export declare function validateMountPath(path: unknown): asserts path is string;

package/dist/browser.js

@@ -118,6 +118,9 @@ var init_client = __esm({
       unmount(path) {
         return this.request({ id: this.nextId++, type: "unmount", path });
       }
+      refreshMount(path) {
+        return this.request({ id: this.nextId++, type: "refreshMount", path });
+      }
       pollQuery(query) {
         return this.request({ id: this.nextId++, type: "pollQuery", query });
       }
@@ -498,17 +501,24 @@ var EngineQueryOperation = class {
   }
 };
 var MountedResourceImpl = class {
-  constructor(path, unmount, cleanup) {
+  constructor(path, unmount, refreshMount, cleanup) {
     this.path = path;
     this.unmount = unmount;
+    this.refreshMount = refreshMount;
     this.cleanup = cleanup;
   }
   path;
   unmount;
+  refreshMount;
   cleanup;
   closed = false;
   closing;
   cleaned = false;
+  async refresh() {
+    if (this.closed) throw new Error("mounted resource is closed");
+    if (this.closing) throw new Error("mounted resource is closing");
+    await this.refreshMount(this.path);
+  }
   async close() {
     if (this.closed) return;
     if (!this.closing) {
@@ -577,7 +587,14 @@ var HyperDB = class _HyperDB {
       expectOk(result, "mount");
       const mountedPath = new TextDecoder("utf-8", { fatal: true }).decode(result.payload);
       if (mountedPath !== path) throw new Error("mount returned an invalid path");
-      const resource = new MountedResourceImpl(mountedPath, (mounted) => this.unmount(mounted), cleanup);
+      const resource = new MountedResourceImpl(
+        mountedPath,
+        (mounted) => this.unmount(mounted),
+        (path2) => this.runDatabaseOperation(async () => {
+          expectOk(await this.client.refreshMount(path2), "refresh mount");
+        }),
+        cleanup
+      );
       this.mountedResources.add(resource);
       return resource;
     });

package/dist/browser_external_directory.d.ts

@@ -13,6 +13,7 @@ export declare class BrowserExternalDirectoryBackend implements ExternalDirector
         readonly locator: string;
     };
     registered(path: string, locator: string): void;
+    refresh(path: string): void;
     removed(pathOrLocator: string): void;
     list(locator: string): Promise<readonly string[]>;
     listEntries(locator: string, path: string): Promise<readonly BrowserDirectoryEntry[]>;

package/dist/browser_worker.js

@@ -61,6 +61,7 @@
     registerExternalFile;
     registerExternalDirectory;
     removeExternalRegistration;
+    refreshExternalDirectory;
     projectExternalFile;
     projectExternalDirectory;
     startQuery;
@@ -71,6 +72,7 @@
     resultPayloadLength;
     free;
     mountedPaths = /* @__PURE__ */ new Set();
+    mountedDirectoryPaths = /* @__PURE__ */ new Set();
     constructor(module) {
       this.module = module;
       this.initialize = module.cwrap("hyperdb_wasm_initialize", "pointer", ["string", "string", "number"]);
@@ -80,6 +82,7 @@
       this.registerExternalFile = module.cwrap("hyperdb_wasm_register_external_file", "pointer", ["string", "string", "number", "number"]);
       this.registerExternalDirectory = module.cwrap("hyperdb_wasm_register_external_directory", "pointer", ["string", "string", "number", "number"]);
       this.removeExternalRegistration = module.cwrap("hyperdb_wasm_remove_external_registration", "pointer", ["string", "number"]);
+      this.refreshExternalDirectory = module.cwrap("hyperdb_wasm_refresh_external_directory", "pointer", ["string", "number"]);
       this.projectExternalFile = module.cwrap("hyperdb_wasm_project_external_file", "pointer", ["string", "string", "number", "number"]);
       this.projectExternalDirectory = module.cwrap("hyperdb_wasm_project_external_directory", "pointer", ["string", "string", "number"]);
       this.startQuery = module.cwrap("hyperdb_wasm_query_start", "pointer", ["number", "string", "number", "number"]);
@@ -108,11 +111,22 @@
       if (request.type === "mount" && request.source.kind === "browser-file") {
         return this.mountFile(request, request.source.url, safeInteger(request.source.size, "external file size"));
       }
+      if (request.type === "refreshMount") {
+        validateCString(request.path, "external registration path");
+        const backend = this.module.externalDirectoryBackend;
+        if (!backend) return { response: { id: request.id, type: "response", result: { state: "error", error: "External directories are not supported by this client" } }, transfer: [] };
+        if (!this.mountedDirectoryPaths.has(request.path)) {
+          const error = this.mountedPaths.has(request.path) ? "Only directory mounts can be refreshed" : "External directory registration was not found";
+          return { response: { id: request.id, type: "response", result: { state: "error", error } }, transfer: [] };
+        }
+        backend.refresh(request.path);
+      }
       if (request.type === "unmount" && (this.module.externalFileBackend || this.module.externalDirectoryBackend)) {
         validateCString(request.path, "external registration path");
         const pointer2 = safeInteger(this.removeExternalRegistration(request.path, request.id), "result pointer");
         const result2 = this.decodeResult(pointer2);
         if (result2.state === "ok" || result2.state === "error" && result2.error === "External registration was not found" && this.mountedPaths.has(request.path)) {
+          this.mountedDirectoryPaths.delete(request.path);
           const cleanup = async () => {
             await Promise.all([
               this.module.externalFileBackend?.removed(request.path),
@@ -130,6 +144,8 @@
       const pointer = safeInteger(this.invoke(request), "result pointer");
       const result = this.decodeResult(pointer);
       if (request.type === "shutdown" && result.state === "ok") {
+        this.mountedPaths.clear();
+        this.mountedDirectoryPaths.clear();
         const completion = completionFor([
           this.module.externalFileBackend?.shutdown(),
           this.module.externalDirectoryBackend?.shutdown()
@@ -141,6 +157,7 @@
         };
       }
       const response = { id: request.id, type: "response", result };
+      if (request.type === "unmount" && result.state === "ok") this.mountedPaths.delete(request.path);
       return { response, transfer: result.state === "chunk" ? [result.payload.buffer] : [] };
     }
     invoke(request) {
@@ -164,6 +181,8 @@
         case "unmount":
           validateCString(request.path, "external registration path");
           return this.removeExternalRegistration(request.path, request.id);
+        case "refreshMount":
+          return this.refreshExternalDirectory(request.path, request.id);
         case "startQuery":
           validateCStringContents(request.sql, "SQL");
           return this.startQuery(request.connection, request.sql, Number(request.sqlTestMode ?? false), request.id);
@@ -234,12 +253,14 @@
             if (projection.state !== "ok") throw new Error(resultError(projection));
             backend.registered(path, registration.locator);
             this.mountedPaths.add(path);
+            this.mountedDirectoryPaths.add(path);
           } catch (error) {
             const cleanupPointer = safeInteger(this.removeExternalRegistration(path, request.id), "result pointer");
             const cleanup = this.decodeResult(cleanupPointer);
             if (cleanup.state !== "ok") {
               backend.registered(path, registration.locator);
               this.mountedPaths.add(path);
+              this.mountedDirectoryPaths.add(path);
               preserveBackend = true;
               throw new Error(`mount failed and rollback also failed: ${resultError(cleanup)}`, { cause: error });
             }
@@ -343,6 +364,7 @@
         }
       }
       case "unmount":
+      case "refreshMount":
         return hasKeys(value, ["id", "type", "path"]) && typeof value.path === "string" && !!value.path && !value.path.includes("\0");
       case "pollQuery":
       case "cancelQuery":
@@ -671,6 +693,12 @@
       if (!this.directories.has(locator)) throw new Error("External directory registration is unavailable");
       this.paths.set(path, locator);
     }
+    /// Clears future path lookups, retaining File locators until lease-protected mount removal
+    refresh(path) {
+      const locator = this.paths.get(path);
+      if (locator === void 0) throw new Error("External directory registration does not exist");
+      this.getDirectory(locator).files.clear();
+    }
     removed(pathOrLocator) {
       const locator = this.paths.get(pathOrLocator) ?? pathOrLocator;
       const directory = this.directories.get(locator);
@@ -755,7 +783,7 @@
         const file = await snapshot;
         return { locator: file.locator, size: file.file.size };
       } catch (error) {
-        directory.files.delete(path);
+        if (directory.files.get(path) === snapshot) directory.files.delete(path);
         throw error;
       }
     }

package/dist/client.d.ts

@@ -19,6 +19,7 @@ export declare class HyperDBEngineClient {
     startQuery(connection: number, sql: string, sqlTestMode?: boolean): Promise<WasmResult>;
     mount(source: MountSource, path: string, mode: MountAccessMode): Promise<WasmResult>;
     unmount(path: string): Promise<WasmResult>;
+    refreshMount(path: string): Promise<WasmResult>;
     pollQuery(query: number): Promise<WasmResult>;
     cancelQuery(query: number): Promise<WasmResult>;
     finishQuery(query: number): Promise<WasmResult>;