@fireproof/core 0.19.0-dev-publish → 0.19.0-dev-global

package/index.js

@@ -1,20 +1,23 @@
 import {
   guardVersion
-} from "./chunk-EVSZA26U.js";
+} from "./chunk-AZVWSRER.js";
 import {
   NotFoundError,
   isNotFoundError
 } from "./chunk-VZGT7ZYP.js";
 import {
   dataDir,
+  decodeFile,
+  encodeFile,
   ensureLogger,
   exception2Result,
   exceptionWrapper,
   getKey,
   getName,
   getStore,
-  runtime_exports
-} from "./chunk-UCMXU3DH.js";
+  runtime_exports,
+  toCryptoOpts
+} from "./chunk-NZNG6TQT.js";
 import {
   SysContainer,
   __export,
@@ -274,72 +277,6 @@ var ConnectREST = class extends ConnectionBase {
 // src/blockstore/store-factory.ts
 import { KeyedResolvOnce } from "@adviser/cement";
 
-// src/runtime/files.ts
-import * as UnixFS from "@ipld/unixfs";
-import * as raw from "multiformats/codecs/raw";
-import { withMaxChunkSize } from "@ipld/unixfs/file/chunker/fixed";
-import { withWidth } from "@ipld/unixfs/file/layout/balanced";
-import { exporter } from "ipfs-unixfs-exporter";
-var queuingStrategy = UnixFS.withCapacity();
-var settings = UnixFS.configure({
-  fileChunkEncoder: raw,
-  smallFileEncoder: raw,
-  chunker: withMaxChunkSize(1024 * 1024),
-  fileLayout: withWidth(1024)
-});
-async function collect(collectable) {
-  const chunks = [];
-  await collectable.pipeTo(
-    new WritableStream({
-      write(chunk) {
-        chunks.push(chunk);
-      }
-    })
-  );
-  return chunks;
-}
-async function encodeFile(blob) {
-  const readable = createFileEncoderStream(blob);
-  const blocks = await collect(readable);
-  return { cid: blocks.at(-1).cid, blocks };
-}
-async function decodeFile(blocks, cid, meta) {
-  const entry = await exporter(cid.toString(), blocks, { length: meta.size });
-  const chunks = [];
-  for await (const chunk of entry.content()) {
-    chunks.push(chunk);
-  }
-  return new File(chunks, entry.name, { type: meta.type, lastModified: 0 });
-}
-function createFileEncoderStream(blob) {
-  const { readable, writable } = new TransformStream({}, queuingStrategy);
-  const unixfsWriter = UnixFS.createWriter({ writable, settings });
-  const fileBuilder = new UnixFSFileBuilder("", blob);
-  void (async () => {
-    await fileBuilder.finalize(unixfsWriter);
-    await unixfsWriter.close();
-  })();
-  return readable;
-}
-var UnixFSFileBuilder = class {
-  #file;
-  constructor(name, file) {
-    this.name = name;
-    this.#file = file;
-  }
-  async finalize(writer) {
-    const unixfsFileWriter = UnixFS.createFileWriter(writer);
-    await this.#file.stream().pipeTo(
-      new WritableStream({
-        async write(chunk) {
-          await unixfsFileWriter.write(chunk);
-        }
-      })
-    );
-    return await unixfsFileWriter.close();
-  }
-};
-
 // src/blockstore/store.ts
 import pLimit2 from "p-limit";
 import { format, parse } from "@ipld/dag-json";
@@ -358,7 +295,7 @@ function toCIDBlock(block) {
 // src/blockstore/loader-helpers.ts
 import { encode, decode } from "multiformats/block";
 import { sha256 as hasher } from "multiformats/hashes/sha2";
-import * as raw2 from "multiformats/codecs/raw";
+import * as raw from "multiformats/codecs/raw";
 import * as CBW from "@ipld/car/buffer-writer";
 import * as codec from "@ipld/dag-cbor";
 async function encodeCarFile(roots, t) {
@@ -377,7 +314,7 @@ async function encodeCarFile(roots, t) {
     writer.write({ cid, bytes });
   }
   writer.close();
-  return await encode({ value: writer.bytes, hasher, codec: raw2 });
+  return await encode({ value: writer.bytes, hasher, codec: raw });
 }
 async function encodeCarHeader(fp) {
   return await encode({
@@ -410,7 +347,7 @@ import { create, load } from "prolly-trees/cid-set";
 
 // src/blockstore/encrypt-codec.ts
 import { CID } from "multiformats";
-function makeCodec(ilogger, crypto2, randomBytes2) {
+function makeCodec(ilogger, crypto, randomBytes) {
   const logger = ensureLogger(ilogger, "makeCodec");
   const enc32 = (value) => {
     value = +value;
@@ -444,7 +381,7 @@ function makeCodec(ilogger, crypto2, randomBytes2) {
   };
   const code = 3145728 + 1337;
   async function subtleKey(key) {
-    return await crypto2.importKey(
+    return await crypto.importKey(
       "raw",
       // raw or jwk
       key,
@@ -458,7 +395,7 @@ function makeCodec(ilogger, crypto2, randomBytes2) {
   const decrypt = async ({ key, value }) => {
     const { bytes: inBytes, iv } = value;
     const cryKey = await subtleKey(key);
-    const deBytes = await crypto2.decrypt(
+    const deBytes = await crypto.decrypt(
       {
         name: "AES-GCM",
         iv,
@@ -474,11 +411,11 @@ function makeCodec(ilogger, crypto2, randomBytes2) {
   };
   const encrypt = async ({ key, cid, bytes }) => {
     const len = enc32(cid.bytes.byteLength);
-    const iv = randomBytes2(12);
+    const iv = randomBytes(12);
     const msg = concat([len, cid.bytes, bytes]);
     try {
       const cryKey = await subtleKey(key);
-      const deBytes = await crypto2.encrypt(
+      const deBytes = await crypto.encrypt(
         {
           name: "AES-GCM",
           iv,
@@ -506,8 +443,8 @@ function carLogIncludesGroup(list, cidMatch) {
     return cid.toString() === cidMatch.toString();
   });
 }
-function makeEncDec(logger, crypto2, randomBytes2) {
-  const codec4 = makeCodec(logger, crypto2, randomBytes2);
+function makeEncDec(logger, crypto, randomBytes) {
+  const codec4 = makeCodec(logger, crypto, randomBytes);
   const encrypt = async function* ({
     get: get2,
     cids,
@@ -600,7 +537,7 @@ function hexStringToUint8Array(hexString) {
   }
   return uint8Array;
 }
-async function encryptedEncodeCarFile(logger, crypto2, key, rootCid, t) {
+async function encryptedEncodeCarFile(logger, crypto, key, rootCid, t) {
   const encryptionKey = hexStringToUint8Array(key);
   const encryptedBlocks = new MemoryBlockstore2();
   const cidsToEncrypt = [];
@@ -610,7 +547,7 @@ async function encryptedEncodeCarFile(logger, crypto2, key, rootCid, t) {
     if (!g) throw logger.Error().Ref("cid", cid).Int("bytes", bytes.length).Msg("missing cid block").AsError();
   }
   let last = null;
-  const { encrypt } = makeEncDec(logger, crypto2, crypto2.randomBytes);
+  const { encrypt } = makeEncDec(logger, crypto, crypto.randomBytes);
   for await (const block of encrypt({
     cids: cidsToEncrypt,
     get: t.get.bind(t),
@@ -627,17 +564,17 @@ async function encryptedEncodeCarFile(logger, crypto2, key, rootCid, t) {
   const encryptedCar = await encodeCarFile([last.cid], encryptedBlocks);
   return encryptedCar;
 }
-async function decodeEncryptedCar(logger, crypto2, key, reader) {
+async function decodeEncryptedCar(logger, crypto, key, reader) {
   const roots = await reader.getRoots();
   const root3 = roots[0];
-  return await decodeCarBlocks(logger, crypto2, root3, reader.get.bind(reader), key);
+  return await decodeCarBlocks(logger, crypto, root3, reader.get.bind(reader), key);
 }
-async function decodeCarBlocks(logger, crypto2, root3, get2, keyMaterial) {
+async function decodeCarBlocks(logger, crypto, root3, get2, keyMaterial) {
   const decryptionKeyUint8 = hexStringToUint8Array(keyMaterial);
   const decryptionKey = decryptionKeyUint8.buffer.slice(0, decryptionKeyUint8.byteLength);
   const decryptedBlocks = new MemoryBlockstore2();
   let last = null;
-  const { decrypt } = makeEncDec(logger, crypto2, crypto2.randomBytes);
+  const { decrypt } = makeEncDec(logger, crypto, crypto.randomBytes);
   for await (const block of decrypt({
     root: root3,
     get: get2,
@@ -655,30 +592,6 @@ async function decodeCarBlocks(logger, crypto2, root3, get2, keyMaterial) {
 
 // src/blockstore/transaction.ts
 import { MemoryBlockstore as MemoryBlockstore3 } from "@web3-storage/pail/block";
-
-// src/runtime/crypto.ts
-function randomBytes(size) {
-  const bytes = new Uint8Array(size);
-  if (size > 0) {
-    crypto.getRandomValues(bytes);
-  }
-  return bytes;
-}
-function digestSHA256(data) {
-  return Promise.resolve(crypto.subtle.digest("SHA-256", data));
-}
-function toCryptoOpts(cryptoOpts = {}) {
-  const opts = {
-    importKey: cryptoOpts.importKey || crypto.subtle.importKey.bind(crypto.subtle),
-    encrypt: cryptoOpts.encrypt || crypto.subtle.encrypt.bind(crypto.subtle),
-    decrypt: cryptoOpts.decrypt || crypto.subtle.decrypt.bind(crypto.subtle),
-    randomBytes: cryptoOpts.randomBytes || randomBytes,
-    digestSHA256: cryptoOpts.digestSHA256 || digestSHA256
-  };
-  return opts;
-}
-
-// src/blockstore/transaction.ts
 var CarTransaction = class extends MemoryBlockstore3 {
   constructor(parent, opts = { add: true }) {
     super();
@@ -1689,6 +1602,11 @@ function toURL(pathOrUrl, isIndex) {
   }
 }
 var storeFactory = /* @__PURE__ */ new Map();
+function ensureName(name, url) {
+  if (!url.searchParams.has("name")) {
+    url.searchParams.set("name", name);
+  }
+}
 function buildURL(optURL, loader) {
   const storeOpts = loader.ebOpts.store;
   const obuItem = Array.from(storeFactory.values()).find((items) => items.overrideBaseURL);
@@ -1729,6 +1647,7 @@ function loadDataGateway(url, logger) {
 var onceDataStoreFactory = new KeyedResolvOnce();
 async function dataStoreFactory(loader) {
   const url = buildURL(loader.ebOpts.store.stores?.data, loader);
+  ensureName(loader.name, url);
   const logger = ensureLogger(loader.logger, "dataStoreFactory", { url: url.toString() });
   url.searchParams.set("store", "data");
   return onceDataStoreFactory.get(url.toString()).once(async () => {
@@ -1748,15 +1667,14 @@ function loadMetaGateway(url, logger) {
 var onceMetaStoreFactory = new KeyedResolvOnce();
 async function metaStoreFactory(loader) {
   const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  ensureName(loader.name, url);
   const logger = ensureLogger(loader.logger, "metaStoreFactory", { url: () => url.toString() });
   url.searchParams.set("store", "meta");
   return onceMetaStoreFactory.get(url.toString()).once(async () => {
     logger.Debug().Str("protocol", url.protocol).Msg("pre-protocol switch");
     const gateway = await loadMetaGateway(url, logger);
     const store = new MetaStore(loader.name, url, loader.logger, gateway);
-    logger.Debug().Msg("pre-start");
     await store.start();
-    logger.Debug().Msg("post-start");
     return store;
   });
 }
@@ -1769,6 +1687,7 @@ function loadWalGateway(url, logger) {
 var onceRemoteWalFactory = new KeyedResolvOnce();
 async function remoteWalFactory(loader) {
   const url = buildURL(loader.ebOpts.store.stores?.meta, loader);
+  ensureName(loader.name, url);
   const logger = ensureLogger(loader.logger, "remoteWalFactory", { url: url.toString() });
   url.searchParams.set("store", "wal");
   return onceRemoteWalFactory.get(url.toString()).once(async () => {
@@ -1810,57 +1729,57 @@ function toStoreRuntime(opts, ilogger) {
 registerStoreProtocol({
   protocol: "file:",
   data: async (logger) => {
-    const { FileDataGateway } = await import("./store-file-D472VFCS.js");
+    const { FileDataGateway } = await import("./store-file-CSS5THFH.js");
     return new FileDataGateway(logger);
   },
   meta: async (logger) => {
-    const { FileMetaGateway } = await import("./store-file-D472VFCS.js");
+    const { FileMetaGateway } = await import("./store-file-CSS5THFH.js");
     return new FileMetaGateway(logger);
   },
   wal: async (logger) => {
-    const { FileWALGateway } = await import("./store-file-D472VFCS.js");
+    const { FileWALGateway } = await import("./store-file-CSS5THFH.js");
     return new FileWALGateway(logger);
   },
   test: async (logger) => {
-    const { FileTestStore } = await import("./store-file-D472VFCS.js");
+    const { FileTestStore } = await import("./store-file-CSS5THFH.js");
     return new FileTestStore(logger);
   }
 });
 registerStoreProtocol({
   protocol: "indexdb:",
   data: async (logger) => {
-    const { IndexDBDataGateway } = await import("./store-indexdb-FRX5PTKR.js");
+    const { IndexDBDataGateway } = await import("./store-indexdb-DR4HELVP.js");
     return new IndexDBDataGateway(logger);
   },
   meta: async (logger) => {
-    const { IndexDBMetaGateway } = await import("./store-indexdb-FRX5PTKR.js");
+    const { IndexDBMetaGateway } = await import("./store-indexdb-DR4HELVP.js");
     return new IndexDBMetaGateway(logger);
   },
   wal: async (logger) => {
-    const { IndexDBMetaGateway } = await import("./store-indexdb-FRX5PTKR.js");
+    const { IndexDBMetaGateway } = await import("./store-indexdb-DR4HELVP.js");
     return new IndexDBMetaGateway(logger);
   },
   test: async (logger) => {
-    const { IndexDBTestStore } = await import("./store-indexdb-FRX5PTKR.js");
+    const { IndexDBTestStore } = await import("./store-indexdb-DR4HELVP.js");
     return new IndexDBTestStore(logger);
   }
 });
 registerStoreProtocol({
   protocol: "sqlite:",
   data: async (logger) => {
-    const { SQLDataGateway } = await import("./store-sql-MDSU23Y7.js");
+    const { SQLDataGateway } = await import("./store-sql-BG6SMGQJ.js");
     return new SQLDataGateway(logger);
   },
   meta: async (logger) => {
-    const { SQLMetaGateway } = await import("./store-sql-MDSU23Y7.js");
+    const { SQLMetaGateway } = await import("./store-sql-BG6SMGQJ.js");
     return new SQLMetaGateway(logger);
   },
   wal: async (logger) => {
-    const { SQLWalGateway } = await import("./store-sql-MDSU23Y7.js");
+    const { SQLWalGateway } = await import("./store-sql-BG6SMGQJ.js");
     return new SQLWalGateway(logger);
   },
   test: async (logger) => {
-    const { SQLTestStore } = await import("./store-sql-MDSU23Y7.js");
+    const { SQLTestStore } = await import("./store-sql-BG6SMGQJ.js");
     return new SQLTestStore(logger);
   }
 });