@fireproof/core 0.20.0-dev-preview-54 → 0.20.0-dev-preview-55

package/index.js

@@ -5,7 +5,7 @@ var __export = (target, all) => {
 };
 
 // src/ledger.ts
-import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce6, ResolveOnce as ResolveOnce7, URI as URI13 } from "@adviser/cement";
+import { BuildURI as BuildURI2, KeyedResolvOnce as KeyedResolvOnce5, ResolveOnce as ResolveOnce7, URI as URI13 } from "@adviser/cement";
 
 // src/utils.ts
 import {
@@ -2113,6 +2113,9 @@ var DatabaseImpl = class {
     const result = await this.ledger.writeQueue.push({ id, del: true });
     return { id, clock: result?.head, name: this.name };
   }
+  async remove(id) {
+    return this.del(id);
+  }
   async changes(since = [], opts = {}) {
     await this.ready();
     this.logger.Debug().Any("since", since).Any("opts", opts).Msg("changes");
@@ -2179,6 +2182,7 @@ __export(blockstore_exports, {
   MetaActiveStore: () => MetaActiveStore,
   PassThroughGateway: () => PassThroughGateway,
   TaskManager: () => TaskManager,
+  URIInterceptor: () => URIInterceptor,
   WALActiveStore: () => WALActiveStore,
   createAttachedStores: () => createAttachedStores,
   createDbMetaEvent: () => createDbMetaEvent,
@@ -2186,7 +2190,7 @@ __export(blockstore_exports, {
   ensureStoreEnDeFile: () => ensureStoreEnDeFile,
   getDefaultURI: () => getDefaultURI,
   getGatewayFactoryItem: () => getGatewayFactoryItem,
-  getStartedGateway: () => getStartedGateway,
+  getInterceptableGateway: () => getInterceptableGateway,
   parseCarFile: () => parseCarFile,
   registerStoreProtocol: () => registerStoreProtocol,
   toCIDBlock: () => toCIDBlock,
@@ -2246,10 +2250,10 @@ var WALActiveStore = class extends BaseActiveStore {
 };
 
 // src/blockstore/store-factory.ts
-import { KeyedResolvOnce as KeyedResolvOnce5, Result as Result11 } from "@adviser/cement";
+import { Result as Result11 } from "@adviser/cement";
 
 // src/blockstore/store.ts
-import { exception2Result as exception2Result4, ResolveOnce as ResolveOnce4, Result as Result10 } from "@adviser/cement";
+import { exception2Result as exception2Result4, ResolveOnce as ResolveOnce4, Result as Result9 } from "@adviser/cement";
 
 // src/blockstore/loader.ts
 import pLimit from "p-limit";
@@ -3579,151 +3583,11 @@ import { EventBlock as EventBlock2 } from "@fireproof/vendor/@web3-storage/pail/
 import { format as format2 } from "@ipld/dag-json";
 import pRetry from "p-retry";
 import pMap from "p-map";
-
-// src/blockstore/interceptor-gateway.ts
-import { Result as Result9 } from "@adviser/cement";
-var PassThroughGateway = class {
-  async buildUrl(ctx, url, key) {
-    const op = { url, key };
-    return Result9.Ok({ op });
-  }
-  async start(ctx, url) {
-    const op = { url };
-    return Result9.Ok({ op });
-  }
-  async close(ctx, url) {
-    const op = { url };
-    return Result9.Ok({ op });
-  }
-  async delete(ctx, url) {
-    const op = { url };
-    return Result9.Ok({ op });
-  }
-  async destroy(ctx, url) {
-    const op = { url };
-    return Result9.Ok({ op });
-  }
-  async put(ctx, url, body) {
-    const op = { url, body };
-    return Result9.Ok({ op });
-  }
-  async get(ctx, url) {
-    const op = { url };
-    return Result9.Ok({ op });
-  }
-  async subscribe(ctx, url, callback) {
-    const op = { url, callback };
-    return Result9.Ok({ op });
-  }
-};
-var passThrougthGateway = new PassThroughGateway();
-var InterceptorGateway = class {
-  constructor(sthis, innerGW, interceptor) {
-    this.innerGW = innerGW;
-    this.interceptor = interceptor || passThrougthGateway;
-  }
-  async buildUrl(ctx, baseUrl, key) {
-    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
-  }
-  async destroy(ctx, iurl) {
-    const rret = await this.interceptor.destroy(ctx, iurl);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.destroy(ctx, ret.op.url);
-  }
-  async start(ctx, url) {
-    const rret = await this.interceptor.start(ctx, url);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.start(ctx, ret.op.url);
-  }
-  async close(ctx, url) {
-    const rret = await this.interceptor.close(ctx, url);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return await this.innerGW.close(ctx, ret.op.url);
-  }
-  async put(ctx, url, fpEnv) {
-    const rret = await this.interceptor.put(ctx, url, fpEnv);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
-  }
-  async get(ctx, url) {
-    const rret = await this.interceptor.get(ctx, url);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.get(ctx, ret.op.url);
-  }
-  async subscribe(ctx, url, callback) {
-    if (!this.innerGW.subscribe) {
-      return Result9.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
-    }
-    const rret = await this.interceptor.subscribe(ctx, url, callback);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
-  }
-  async delete(ctx, url) {
-    const rret = await this.interceptor.delete(ctx, url);
-    if (rret.isErr()) {
-      return Result9.Err(rret.Err());
-    }
-    const ret = rret.unwrap();
-    if (ret.stop && ret.value) {
-      return ret.value;
-    }
-    return this.innerGW.delete(ctx, url);
-  }
-  async getPlain(ctx, url, key) {
-    return this.innerGW.getPlain(ctx, url, key);
-  }
-};
-
-// src/blockstore/store.ts
 function guardVersion(url) {
   if (!url.hasParam("version")) {
-    return Result10.Err(`missing version: ${url.toString()}`);
+    return Result9.Err(`missing version: ${url.toString()}`);
   }
-  return Result10.Ok(url);
+  return Result9.Ok(url);
 }
 var BaseStoreImpl = class {
   // readonly loader: Loadable;
@@ -3739,8 +3603,10 @@ var BaseStoreImpl = class {
       throw logger.Error().Url(this._url).Msg("missing name").AsError();
     }
     this.logger = logger.With().Str("this", this.sthis.nextId().str).Ref("url", () => this._url.toString()).Logger();
-    this.realGateway = opts.gateway;
-    this.gateway = new InterceptorGateway(this.sthis, opts.gateway, opts.gatewayInterceptor);
+    this.gateway = opts.gateway;
+  }
+  get realGateway() {
+    return this.gateway.innerGW;
   }
   url() {
     return this._url;
@@ -3890,7 +3756,7 @@ var MetaStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result10.Ok(void 0);
+    return Result9.Ok(void 0);
   }
   async destroy() {
     this.logger.Debug().Msg("destroy");
@@ -3957,7 +3823,7 @@ var DataStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result10.Ok(void 0);
+    return Result9.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4044,7 +3910,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
     const retryableUpload = (fn, description) => pRetry(fn, {
       retries: 5,
       onFailedAttempt: (error) => {
-        this.logger.Warn().Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
+        this.logger.Warn().Any("error", error).Any("fn", fn.toString()).Msg(`Attempt ${error.attemptNumber} failed for ${description}. There are ${error.retriesLeft} retries left.`);
       }
     });
     try {
@@ -4159,7 +4025,7 @@ var WALStoreImpl = class extends BaseStoreImpl {
   async close() {
     await this.gateway.close({ loader: this.loader }, this.url());
     this._onClosed.forEach((fn) => fn());
-    return Result10.Ok(void 0);
+    return Result9.Ok(void 0);
   }
   destroy() {
     this.logger.Debug().Msg("destroy");
@@ -4167,81 +4033,200 @@ var WALStoreImpl = class extends BaseStoreImpl {
   }
 };
 
-// src/blockstore/store-factory.ts
-var onceGateway = new KeyedResolvOnce5();
-var gatewayInstances = new KeyedResolvOnce5();
-async function getStartedGateway(ctx, url) {
-  return onceGateway.get(url.toString()).once(async () => {
-    const item = getGatewayFactoryItem(url.protocol);
-    if (item) {
-      const ret = {
-        url,
-        ...await gatewayInstances.get(url.protocol).once(async () => ({
-          gateway: await item.serdegateway(ctx.loader.sthis)
-        }))
-      };
-      const res = await ret.gateway.start(ctx, url);
-      if (res.isErr()) {
-        return Result11.Err(ctx.loader.sthis.logger.Error().Result("start", res).Msg("start failed").AsError());
-      }
-      ret.url = res.Ok();
-      return Result11.Ok(ret);
+// src/blockstore/interceptor-gateway.ts
+import { Result as Result10 } from "@adviser/cement";
+var PassThroughGateway = class {
+  async buildUrl(ctx, url, key) {
+    const op = { url, key };
+    return Result10.Ok({ op });
+  }
+  async start(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async close(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async delete(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async destroy(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async put(ctx, url, body) {
+    const op = { url, body };
+    return Result10.Ok({ op });
+  }
+  async get(ctx, url) {
+    const op = { url };
+    return Result10.Ok({ op });
+  }
+  async subscribe(ctx, url, callback) {
+    const op = { url, callback };
+    return Result10.Ok({ op });
+  }
+};
+var passThrougthGateway = new PassThroughGateway();
+var InterceptorGateway = class {
+  constructor(sthis, innerGW, interceptor) {
+    this.innerGW = innerGW;
+    this.interceptor = interceptor || passThrougthGateway;
+  }
+  async buildUrl(ctx, baseUrl, key) {
+    const rret = await this.interceptor.buildUrl(ctx, baseUrl, key);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
     }
-    return Result11.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
-  });
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.buildUrl(ctx, ret.op.url, ret.op.key);
+  }
+  async destroy(ctx, iurl) {
+    const rret = await this.interceptor.destroy(ctx, iurl);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.destroy(ctx, ret.op.url);
+  }
+  async start(ctx, url) {
+    const rret = await this.interceptor.start(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.start(ctx, ret.op.url);
+  }
+  async close(ctx, url) {
+    const rret = await this.interceptor.close(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return await this.innerGW.close(ctx, ret.op.url);
+  }
+  async put(ctx, url, fpEnv) {
+    const rret = await this.interceptor.put(ctx, url, fpEnv);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.put(ctx, ret.op.url, ret.op.body);
+  }
+  async get(ctx, url) {
+    const rret = await this.interceptor.get(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.get(ctx, ret.op.url);
+  }
+  async subscribe(ctx, url, callback) {
+    if (!this.innerGW.subscribe) {
+      return Result10.Err(ctx.loader.sthis.logger.Error().Url(url).Msg("subscribe not supported").AsError());
+    }
+    const rret = await this.interceptor.subscribe(ctx, url, callback);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.subscribe(ctx, ret.op.url, ret.op.callback);
+  }
+  async delete(ctx, url) {
+    const rret = await this.interceptor.delete(ctx, url);
+    if (rret.isErr()) {
+      return Result10.Err(rret.Err());
+    }
+    const ret = rret.unwrap();
+    if (ret.stop && ret.value) {
+      return ret.value;
+    }
+    return this.innerGW.delete(ctx, url);
+  }
+  async getPlain(ctx, url, key) {
+    return this.innerGW.getPlain(ctx, url, key);
+  }
+};
+
+// src/blockstore/store-factory.ts
+async function getInterceptableGateway(ctx, url, opt) {
+  const item = getGatewayFactoryItem(url.protocol);
+  if (item) {
+    return Result11.Ok(new InterceptorGateway(ctx.loader.sthis, await item.serdegateway(ctx.loader.sthis), opt.gatewayInterceptor));
+  }
+  return Result11.Err(ctx.loader.sthis.logger.Warn().Url(url).Msg("unsupported protocol").AsError());
 }
 async function carStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "car").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new CarStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new CarStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function fileStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "file").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new FileStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new FileStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function metaStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "meta").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new MetaStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new MetaStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
 }
 async function WALStoreFactory(ctx, uai) {
   const storeUrl = uai.url.build().setParam(PARAM.STORE, "wal").URI();
-  const rgateway = await getStartedGateway(ctx, storeUrl);
+  const rgateway = await getInterceptableGateway(ctx, storeUrl, uai);
   if (rgateway.isErr()) {
     throw ctx.loader.sthis.logger.Error().Result("err", rgateway).Url(uai.url).Msg("notfound").AsError();
   }
   const gateway = rgateway.Ok();
-  const store = new WALStoreImpl(ctx.loader.sthis, gateway.url, {
-    gateway: gateway.gateway,
-    gatewayInterceptor: uai.gatewayInterceptor,
+  const store = new WALStoreImpl(ctx.loader.sthis, uai.url, {
+    gateway,
     loader: ctx.loader
   });
   return store;
@@ -4289,6 +4274,57 @@ function toStoreRuntime(sthis, endeOpts = {}) {
   };
 }
 
+// src/blockstore/uri-interceptor.ts
+var URIInterceptor = class _URIInterceptor extends PassThroughGateway {
+  static withMapper(mapper) {
+    return new _URIInterceptor().addMapper(mapper);
+  }
+  #uriMapper = /* @__PURE__ */ new Set();
+  addMapper(mapper) {
+    this.#uriMapper.add(mapper);
+    return this;
+  }
+  async #map(uri) {
+    let ret = uri;
+    for (const mapper of this.#uriMapper) {
+      ret = await mapper(ret);
+    }
+    return ret;
+  }
+  async buildUrl(ctx, url, key) {
+    const ret = await super.buildUrl(ctx, await this.#map(url), key);
+    return ret;
+  }
+  async start(ctx, url) {
+    const ret = await super.start(ctx, await this.#map(url));
+    return ret;
+  }
+  async close(ctx, url) {
+    const ret = await super.close(ctx, await this.#map(url));
+    return ret;
+  }
+  async delete(ctx, url) {
+    const ret = await super.delete(ctx, await this.#map(url));
+    return ret;
+  }
+  async destroy(ctx, url) {
+    const ret = await super.destroy(ctx, await this.#map(url));
+    return ret;
+  }
+  async put(ctx, url, body) {
+    const ret = await super.put(ctx, await this.#map(url), body);
+    return ret;
+  }
+  async get(ctx, url) {
+    const ret = await super.get(ctx, await this.#map(url));
+    return ret;
+  }
+  async subscribe(ctx, url, callback) {
+    const ret = await super.subscribe(ctx, await this.#map(url), callback);
+    return ret;
+  }
+};
+
 // src/crdt-helpers.ts
 import { parse as parse2 } from "multiformats/link";
 import { sha256 as hasher6 } from "multiformats/hashes/sha2";
@@ -4942,7 +4978,7 @@ var Context = class {
 };
 
 // src/ledger.ts
-var ledgers = new KeyedResolvOnce6();
+var ledgers = new KeyedResolvOnce5();
 function keyConfigOpts(sthis, name, opts) {
   return JSON.stringify(
     toSortedArray({
@@ -5226,7 +5262,7 @@ __export(file_exports, {
 
 // src/version.ts
 var PACKAGE_VERSION = Object.keys({
-  "0.20.0-dev-preview-54": "xxxx"
+  "0.20.0-dev-preview-55": "xxxx"
 })[0];
 export {
   CRDTImpl,