@fireproof/core 0.19.112-dev-web → 0.19.112-dev-dyn

package/index.d.cts

@@ -1035,9 +1035,9 @@ declare class Database<DT extends DocTypes = NonNullable<unknown>> implements Co
 declare function fireproof(name: string, opts?: ConfigOpts): Database;
 
 declare function getFileSystem(url: URI): Promise<SysFileSystem>;
+
 declare function getPath(url: URI, sthis: SuperThis): string;
 declare function getFileName(url: URI, sthis: SuperThis): string;
-declare function toArrayBuffer(buffer: Buffer | string): Uint8Array;
 
 declare function encodeFile(blob: BlobLike): Promise<{
     cid: AnyLink;
@@ -1128,9 +1128,8 @@ declare const index_getFileName: typeof getFileName;
 declare const index_getFileSystem: typeof getFileSystem;
 declare const index_getPath: typeof getPath;
 declare const index_runtimeFn: typeof runtimeFn;
-declare const index_toArrayBuffer: typeof toArrayBuffer;
 declare namespace index {
-  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, index_files as files, index_getFileName as getFileName, index_getFileSystem as getFileSystem, index_getPath as getPath, keyBag as kb, keyedCrypto as kc, index$1 as mf, index_runtimeFn as runtimeFn, index_toArrayBuffer as toArrayBuffer };
+  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, index_files as files, index_getFileName as getFileName, index_getFileSystem as getFileSystem, index_getPath as getPath, keyBag as kb, keyedCrypto as kc, index$1 as mf, index_runtimeFn as runtimeFn };
 }
 
 declare const PACKAGE_VERSION: string;

package/index.d.ts

@@ -1035,9 +1035,9 @@ declare class Database<DT extends DocTypes = NonNullable<unknown>> implements Co
 declare function fireproof(name: string, opts?: ConfigOpts): Database;
 
 declare function getFileSystem(url: URI): Promise<SysFileSystem>;
+
 declare function getPath(url: URI, sthis: SuperThis): string;
 declare function getFileName(url: URI, sthis: SuperThis): string;
-declare function toArrayBuffer(buffer: Buffer | string): Uint8Array;
 
 declare function encodeFile(blob: BlobLike): Promise<{
     cid: AnyLink;
@@ -1128,9 +1128,8 @@ declare const index_getFileName: typeof getFileName;
 declare const index_getFileSystem: typeof getFileSystem;
 declare const index_getPath: typeof getPath;
 declare const index_runtimeFn: typeof runtimeFn;
-declare const index_toArrayBuffer: typeof toArrayBuffer;
 declare namespace index {
-  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, index_files as files, index_getFileName as getFileName, index_getFileSystem as getFileSystem, index_getPath as getPath, keyBag as kb, keyedCrypto as kc, index$1 as mf, index_runtimeFn as runtimeFn, index_toArrayBuffer as toArrayBuffer };
+  export { index_FILESTORE_VERSION as FILESTORE_VERSION, index_INDEXDB_VERSION as INDEXDB_VERSION, index_files as files, index_getFileName as getFileName, index_getFileSystem as getFileSystem, index_getPath as getPath, keyBag as kb, keyedCrypto as kc, index$1 as mf, index_runtimeFn as runtimeFn };
 }
 
 declare const PACKAGE_VERSION: string;

package/index.global.js

@@ -12416,51 +12416,54 @@ ${end.comment}` : end.comment;
     }
   });
 
-  // src/bundle-not-impl.ts
-  var require_bundle_not_impl = __commonJS({
-    "src/bundle-not-impl.ts"() {
-      "use strict";
-      var err = new Error("store-file not implemented");
-      console.error(err.stack);
-      throw err;
-    }
-  });
-
-  // src/runtime/gateways/file/utils.ts
-  var utils_exports2 = {};
-  __export(utils_exports2, {
-    getFileName: () => getFileName,
-    getFileSystem: () => getFileSystem,
-    getPath: () => getPath,
-    toArrayBuffer: () => toArrayBuffer
-  });
+  // src/runtime/gateways/file/get-file-system-dynamic.ts
   async function getFileSystem(url) {
-    const name6 = url.getParam("fs");
+    const name6 = url.getParam("fs", "node");
     let fs;
     switch (name6) {
       case "mem":
-        {
-          const { MemFileSystem } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-          fs = new MemFileSystem();
-        }
+        fs = await externalLoaders.get(name6).once(async () => {
+          const memjs = "./node/mem-filesystem.js";
+          const { MemFileSystem } = await import(
+            /* @vite-ignore */
+            memjs
+          );
+          return new MemFileSystem();
+        });
         break;
       // case 'deno': {
       //   const { DenoFileSystem } = await import("./deno-filesystem.js");
       //   fs = new DenoFileSystem();
       //   break;
       // }
-      case "node": {
-        const { NodeFileSystem } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-        fs = new NodeFileSystem();
-        break;
-      }
-      case "sys":
-      default: {
-        return getFileSystem(url.build().setParam("fs", "node").URI());
-      }
+      default:
+        fs = await externalLoaders.get(name6).once(async () => {
+          const nodejs = "./node/node-filesystem.js";
+          const { NodeFileSystem } = await import(
+            /* @vite-ignore */
+            nodejs
+          );
+          return new NodeFileSystem();
+        });
     }
     return fs.start();
   }
+  var externalLoaders;
+  var init_get_file_system_dynamic = __esm({
+    "src/runtime/gateways/file/get-file-system-dynamic.ts"() {
+      "use strict";
+      init_cement();
+      externalLoaders = new KeyedResolvOnce();
+    }
+  });
+
+  // src/runtime/gateways/file/utils.ts
+  var utils_exports2 = {};
+  __export(utils_exports2, {
+    getFileName: () => getFileName,
+    getFileSystem: () => getFileSystem,
+    getPath: () => getPath
+  });
   function getPath(url, sthis) {
     const basePath = url.pathname;
     const name6 = url.getParam("name");
@@ -12485,21 +12488,11 @@ ${end.comment}` : end.comment;
         throw sthis.logger.Error().Url(url).Msg(`unsupported store type`).AsError();
     }
   }
-  function toArrayBuffer(buffer2) {
-    if (typeof buffer2 === "string") {
-      buffer2 = Buffer.from(buffer2);
-    }
-    const ab = new ArrayBuffer(buffer2.length);
-    const view = new Uint8Array(ab);
-    for (let i = 0; i < buffer2.length; ++i) {
-      view[i] = buffer2[i];
-    }
-    return view;
-  }
   var init_utils2 = __esm({
     "src/runtime/gateways/file/utils.ts"() {
       "use strict";
       init_utils();
+      init_get_file_system_dynamic();
     }
   });
 
@@ -13084,173 +13077,228 @@ ${end.comment}` : end.comment;
     }
   });
 
-  // src/runtime/gateways/indexdb/version.ts
-  var INDEXDB_VERSION;
+  // src/runtime/gateways/file/version.ts
+  var FILESTORE_VERSION;
   var init_version = __esm({
-    "src/runtime/gateways/indexdb/version.ts"() {
+    "src/runtime/gateways/file/version.ts"() {
       "use strict";
-      INDEXDB_VERSION = "v0.19-indexdb";
+      FILESTORE_VERSION = "v0.19-file";
     }
   });
 
-  // src/runtime/gateways/indexdb/gateway@skip-esm.ts
-  var gateway_skip_esm_exports = {};
-  __export(gateway_skip_esm_exports, {
-    IndexDBGateway: () => IndexDBGateway,
-    IndexDBTestStore: () => IndexDBTestStore,
-    getIndexDBName: () => getIndexDBName
+  // src/runtime/gateways/file/gateway.ts
+  var gateway_exports = {};
+  __export(gateway_exports, {
+    FileGateway: () => FileGateway,
+    FileTestStore: () => FileTestStore
   });
-  function ensureVersion(url) {
-    return url.build().defParam("version", INDEXDB_VERSION).URI();
-  }
-  function sanitzeKey(key) {
-    if (key.length === 1) {
-      key = key[0];
-    }
-    return key;
-  }
-  async function connectIdb(url, sthis) {
-    const dbName = getIndexDBName(url, sthis);
-    const once = await onceIndexDB.get(dbName.fullDb).once(async () => {
-      const db = await openDB(dbName.fullDb, 1, {
-        upgrade(db2) {
-          ["version", "data", "wal", "meta", "idx.data", "idx.wal", "idx.meta"].map((store) => {
-            db2.createObjectStore(store, {
-              autoIncrement: false
-            });
-          });
-        }
-      });
-      const found = await db.get("version", "version");
-      const version = ensureVersion(url).getParam("version");
-      if (!found) {
-        await db.put("version", { version }, "version");
-      } else if (found.version !== version) {
-        sthis.logger.Warn().Str("url", url.toString()).Str("version", version).Str("found", found.version).Msg("version mismatch");
-      }
-      return { db, dbName, version, url };
-    });
-    return {
-      ...once,
-      url: url.build().setParam("version", once.version).URI()
-    };
-  }
-  function joinDBName(...names) {
-    return names.map((i) => i.replace(/^[^a-zA-Z0-9]+/g, "").replace(/[^a-zA-Z0-9]+/g, "_")).filter((i) => i.length).join(".");
-  }
-  function getIndexDBName(iurl, sthis) {
-    const url = ensureVersion(iurl);
-    const fullDb = url.pathname.replace(/^\/+/, "").replace(/\?.*$/, "");
-    const dbName = url.getParam("name");
-    if (!dbName) throw sthis.logger.Error().Str("url", url.toString()).Msg(`name not found`).AsError();
-    const result = joinDBName(fullDb, dbName);
-    const objStore = getStore(url, sthis, joinDBName).name;
-    const connectionKey = [result, objStore].join(":");
-    return {
-      fullDb: result,
-      objStore,
-      connectionKey,
-      dbName
-    };
-  }
-  var onceIndexDB, IndexDBGateway, IndexDBTestStore;
-  var init_gateway_skip_esm = __esm({
-    "src/runtime/gateways/indexdb/gateway@skip-esm.ts"() {
+  var versionFiles, FileGateway, FileTestStore;
+  var init_gateway = __esm({
+    "src/runtime/gateways/file/gateway.ts"() {
       "use strict";
-      init_build();
-      init_cement();
       init_version();
+      init_cement();
       init_utils();
-      onceIndexDB = new KeyedResolvOnce();
-      IndexDBGateway = class {
+      init_utils2();
+      versionFiles = new KeyedResolvOnce();
+      FileGateway = class {
+        get fs() {
+          if (!this._fs) throw this.logger.Error().Msg("fs not initialized").AsError();
+          return this._fs;
+        }
         constructor(sthis) {
-          this._db = {};
-          this.logger = ensureLogger(sthis, "IndexDBGateway");
           this.sthis = sthis;
+          this.logger = sthis.logger;
+        }
+        async getVersionFromFile(path, logger) {
+          return versionFiles.get(path).once(async () => {
+            await this.fs.mkdir(path, { recursive: true });
+            const vFile = this.sthis.pathOps.join(path, "version");
+            const vFileStat = await this.fs.stat(vFile).catch(() => void 0);
+            if (!vFileStat) {
+              await this.fs.writefile(this.sthis.pathOps.join(path, "version"), FILESTORE_VERSION);
+              return FILESTORE_VERSION;
+            } else if (!vFileStat.isFile()) {
+              throw logger.Error().Str("file", vFile).Msg(`version file is a directory`).AsError();
+            }
+            const v = await this.fs.readfile(vFile);
+            const vStr = this.sthis.txt.decode(v);
+            if (vStr !== FILESTORE_VERSION) {
+              logger.Warn().Str("file", vFile).Str("from", vStr).Str("expected", FILESTORE_VERSION).Msg(`version mismatch`);
+            }
+            return vStr;
+          });
         }
-        async start(baseURL) {
+        start(baseURL) {
           return exception2Result(async () => {
-            this.logger.Debug().Url(baseURL).Msg("starting");
-            await this.sthis.start();
-            const ic = await connectIdb(baseURL, this.sthis);
-            this._db = ic.db;
-            this.logger.Debug().Url(ic.url).Msg("started");
-            return ic.url;
+            this._fs = await getFileSystem(baseURL);
+            await this.fs.start();
+            const url = baseURL.build();
+            url.defParam("version", FILESTORE_VERSION);
+            const dbUrl = await this.buildUrl(url.URI(), "dummy");
+            const dbdirFile = this.getFilePath(dbUrl.Ok());
+            await this.fs.mkdir(this.sthis.pathOps.dirname(dbdirFile), { recursive: true });
+            const dbroot = this.sthis.pathOps.dirname(dbdirFile);
+            this.logger.Debug().Url(url.URI()).Str("dbroot", dbroot).Msg("start");
+            url.setParam("version", await this.getVersionFromFile(dbroot, this.logger));
+            return url.URI();
           });
         }
+        async buildUrl(baseUrl, key) {
+          return Result.Ok(baseUrl.build().setParam("key", key).URI());
+        }
         async close() {
           return Result.Ok(void 0);
         }
-        async destroy(baseUrl) {
+        // abstract buildUrl(baseUrl: URL, key: string): Promise<Result<URL>>;
+        getFilePath(url) {
+          const key = url.getParam("key");
+          if (!key) throw this.logger.Error().Url(url).Msg(`key not found`).AsError();
+          return this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
+        }
+        async put(url, body) {
           return exception2Result(async () => {
-            const type2 = getStore(baseUrl, this.sthis, joinDBName).name;
-            const idb = this._db;
-            const trans = idb.transaction(type2, "readwrite");
-            const object_store = trans.objectStore(type2);
-            const toDelete = [];
-            for (let cursor = await object_store.openCursor(); cursor; cursor = await cursor.continue()) {
-              toDelete.push(cursor.primaryKey);
-            }
-            for (const key of toDelete) {
-              await trans.db.delete(type2, key);
-            }
-            await trans.done;
+            const file = await this.getFilePath(url);
+            this.logger.Debug().Str("url", url.toString()).Str("file", file).Msg("put");
+            await this.fs.writefile(file, body);
           });
         }
-        buildUrl(baseUrl, key) {
-          return Promise.resolve(Result.Ok(baseUrl.build().setParam("key", key).URI()));
-        }
         async get(url) {
           return exceptionWrapper(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("getting");
-            const tx = this._db.transaction([store], "readonly");
-            const bytes = await tx.objectStore(store).get(sanitzeKey(key));
-            await tx.done;
-            if (!bytes) {
-              return Result.Err(new NotFoundError2(`missing ${key}`));
+            const file = this.getFilePath(url);
+            try {
+              const res = await this.fs.readfile(file);
+              this.logger.Debug().Url(url.asURL()).Str("file", file).Msg("get");
+              return Result.Ok(new Uint8Array(res));
+            } catch (e) {
+              if (isNotFoundError(e)) {
+                return Result.Err(new NotFoundError2(`file not found: ${file}`));
+              }
+              return Result.Err(e);
             }
-            return Result.Ok(bytes);
           });
         }
-        async put(url, value) {
+        async delete(url) {
           return exception2Result(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("putting");
-            const tx = this._db.transaction([store], "readwrite");
-            await tx.objectStore(store).put(value, sanitzeKey(key));
-            await tx.done;
+            await this.fs.unlink(this.getFilePath(url));
           });
         }
-        async delete(url) {
-          return exception2Result(async () => {
-            const key = getKey(url, this.logger);
-            const store = getStore(url, this.sthis, joinDBName).name;
-            this.logger.Debug().Url(url).Str("key", key).Str("store", store).Msg("deleting");
-            const tx = this._db.transaction([store], "readwrite");
-            await tx.objectStore(store).delete(sanitzeKey(key));
-            await tx.done;
-            return Result.Ok(void 0);
+        async destroy(baseURL) {
+          const url = await this.buildUrl(baseURL, "x");
+          if (url.isErr()) return url;
+          const filepath = this.sthis.pathOps.dirname(this.getFilePath(url.Ok()));
+          let files = [];
+          try {
+            files = await this.fs.readdir(filepath);
+          } catch (e) {
+            if (!isNotFoundError(e)) {
+              throw this.logger.Error().Err(e).Str("dir", filepath).Msg("destroy:readdir").AsError();
+            }
+          }
+          for (const file of files) {
+            const pathed = this.sthis.pathOps.join(filepath, file);
+            try {
+              await this.fs.unlink(pathed);
+            } catch (e) {
+              if (!isNotFoundError(e)) {
+                throw this.logger.Error().Err(e).Str("file", pathed).Msg("destroy:unlink").AsError();
+              }
+            }
+          }
+          return Result.Ok(void 0);
+        }
+      };
+      FileTestStore = class {
+        constructor(sthis) {
+          this.logger = ensureLogger(sthis, "FileTestStore");
+          this.sthis = sthis;
+        }
+        async get(iurl, key) {
+          const url = iurl.build().setParam("key", key).URI();
+          const dbFile = this.sthis.pathOps.join(getPath(url, this.sthis), getFileName(url, this.sthis));
+          this.logger.Debug().Url(url).Str("dbFile", dbFile).Msg("get");
+          const buffer2 = await (await getFileSystem(url)).readfile(dbFile);
+          this.logger.Debug().Url(url).Str("dbFile", dbFile).Len(buffer2).Msg("got");
+          return buffer2;
+        }
+      };
+    }
+  });
+
+  // src/runtime/gateways/indexdb/gateway-import-dynamic.ts
+  function gatewayImport() {
+    const gwimpl = "./web/gateway-impl.js";
+    return import(
+      /* @vite-ignore */
+      gwimpl
+    );
+  }
+  var init_gateway_import_dynamic = __esm({
+    "src/runtime/gateways/indexdb/gateway-import-dynamic.ts"() {
+      "use strict";
+    }
+  });
+
+  // src/runtime/gateways/indexdb/gateway.ts
+  var gateway_exports2 = {};
+  __export(gateway_exports2, {
+    IndexDBGateway: () => IndexDBGateway,
+    IndexDBTestStore: () => IndexDBTestStore
+  });
+  var loadExternal, IndexDBGateway, IndexDBTestStore;
+  var init_gateway2 = __esm({
+    "src/runtime/gateways/indexdb/gateway.ts"() {
+      "use strict";
+      init_cement();
+      init_gateway_import_dynamic();
+      loadExternal = new ResolveOnce();
+      IndexDBGateway = class {
+        constructor(sthis) {
+          this.sthis = sthis;
+        }
+        getGateway() {
+          return loadExternal.once(() => {
+            return gatewayImport().then(({ IndexDBGatewayImpl }) => new IndexDBGatewayImpl(this.sthis));
           });
         }
+        buildUrl(baseUrl, key) {
+          return this.getGateway().then((gw) => gw.buildUrl(baseUrl, key));
+        }
+        start(baseUrl) {
+          return this.getGateway().then((gw) => gw.start(baseUrl));
+        }
+        close(baseUrl) {
+          return this.getGateway().then((gw) => gw.close(baseUrl));
+        }
+        destroy(baseUrl) {
+          return this.getGateway().then((gw) => gw.destroy(baseUrl));
+        }
+        put(url, body) {
+          return this.getGateway().then((gw) => gw.put(url, body));
+        }
+        get(url) {
+          return this.getGateway().then((gw) => gw.get(url));
+        }
+        delete(url) {
+          return this.getGateway().then((gw) => gw.delete(url));
+        }
+        // subscribe?(url: URI, callback: (meta: Uint8Array) => void): Promise<UnsubscribeResult> {
+        //     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        //     return this.getGateway().then(gw => gw.subscribe!(url, callback));
+        // }
       };
       IndexDBTestStore = class {
         constructor(sthis) {
+          this.loadExternal = new ResolveOnce();
           this.sthis = sthis;
-          this.logger = ensureLogger(sthis, "IndexDBTestStore", {});
         }
-        async get(url, key) {
-          const ic = await connectIdb(url, this.sthis);
-          const store = getStore(ic.url, this.sthis, joinDBName).name;
-          this.logger.Debug().Str("key", key).Str("store", store).Msg("getting");
-          let bytes = await ic.db.get(store, sanitzeKey(key));
-          this.logger.Debug().Str("key", key).Str("store", store).Int("len", bytes.length).Msg("got");
-          if (typeof bytes === "string") {
-            bytes = this.sthis.txt.encode(bytes);
-          }
-          return bytes;
+        getGateway() {
+          return this.loadExternal.once(() => {
+            return gatewayImport().then(({ IndexDBTestStore: IndexDBTestStore2 }) => new IndexDBTestStore2(this.sthis));
+          });
+        }
+        get(url, key) {
+          return this.getGateway().then((gw) => gw.get(url, key));
         }
       };
     }
@@ -28370,22 +28418,22 @@ You can use close({ resize: true }) to resize header`);
   registerStoreProtocol({
     protocol: "file:",
     gateway: async (sthis) => {
-      const { FileGateway } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-      return new FileGateway(sthis);
+      const { FileGateway: FileGateway2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+      return new FileGateway2(sthis);
     },
     test: async (sthis) => {
-      const { FileTestStore } = await Promise.resolve().then(() => __toESM(require_bundle_not_impl(), 1));
-      return new FileTestStore(sthis);
+      const { FileTestStore: FileTestStore2 } = await Promise.resolve().then(() => (init_gateway(), gateway_exports));
+      return new FileTestStore2(sthis);
     }
   });
   registerStoreProtocol({
     protocol: "indexdb:",
     gateway: async (sthis) => {
-      const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway_skip_esm(), gateway_skip_esm_exports));
+      const { IndexDBGateway: IndexDBGateway2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
       return new IndexDBGateway2(sthis);
     },
     test: async (sthis) => {
-      const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway_skip_esm(), gateway_skip_esm_exports));
+      const { IndexDBTestStore: IndexDBTestStore2 } = await Promise.resolve().then(() => (init_gateway2(), gateway_exports2));
       return new IndexDBTestStore2(sthis);
     }
   });
@@ -30758,8 +30806,7 @@ You can use close({ resize: true }) to resize header`);
     kb: () => key_bag_exports,
     kc: () => keyed_crypto_exports,
     mf: () => wait_pr_multiformats_exports,
-    runtimeFn: () => runtimeFn,
-    toArrayBuffer: () => toArrayBuffer
+    runtimeFn: () => runtimeFn
   });
   init_utils2();
 
@@ -30775,19 +30822,17 @@ You can use close({ resize: true }) to resize header`);
 
   // src/runtime/index.ts
   init_cement();
-
-  // src/runtime/gateways/file/version.ts
-  var FILESTORE_VERSION = "v0.19-file";
-
-  // src/runtime/index.ts
   init_version();
 
+  // src/runtime/gateways/indexdb/version.ts
+  var INDEXDB_VERSION = "v0.19-indexdb";
+
   // src/index.ts
   init_utils();
 
   // src/version.ts
   var PACKAGE_VERSION = Object.keys({
-    "0.19.112-dev-web": "xxxx"
+    "0.19.112-dev-dyn": "xxxx"
   })[0];
   return __toCommonJS(src_exports6);
 })();